/* A packrat parser generated by PackCC 1.5.0 */

#ifdef _MSC_VER
#undef _CRT_SECURE_NO_WARNINGS
#define _CRT_SECURE_NO_WARNINGS
#endif /* _MSC_VER */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef _MSC_VER
#if defined __GNUC__ && defined _WIN32 /* MinGW */
#ifndef PCC_USE_SYSTEM_STRNLEN
#define strnlen(str, maxlen) pcc_strnlen(str, maxlen)
static size_t pcc_strnlen(const char *str, size_t maxlen) {
    size_t i;
    for (i = 0; i < maxlen && str[i]; i++);
    return i;
}
#endif /* !PCC_USE_SYSTEM_STRNLEN */
#endif /* defined __GNUC__ && defined _WIN32 */
#endif /* !_MSC_VER */

#define PCC_DBG_EVALUATE 0
#define PCC_DBG_MATCH    1
#define PCC_DBG_NOMATCH  2

#include "llvmir.h"


#include <stdio.h>

static const char *dbg_str[] = { "Evaluating rule", "Matched rule", "Abandoning rule" };

#define PCC_DEBUG(event, rule, level, pos, buffer, length) \
    fprintf(stdout, "%*s%s %s @%d [%.*s]\n", (int)(level * 2), "", dbg_str[event], rule, (int)pos, (int)length,  buffer); fflush(stdout)

    /* NOTE: To guarantee the output order, stderr, which can lead a race condition with stdout, is not used. */

#ifndef PCC_BUFFERSIZE
#define PCC_BUFFERSIZE 256
#endif /* !PCC_BUFFERSIZE */

#ifndef PCC_ARRAYSIZE
#define PCC_ARRAYSIZE 2
#endif /* !PCC_ARRAYSIZE */

#define VOID_VALUE (~(size_t)0)

typedef enum pcc_bool_tag {
    PCC_FALSE = 0,
    PCC_TRUE
} pcc_bool_t;

typedef struct pcc_char_array_tag {
    char *buf;
    size_t max;
    size_t len;
} pcc_char_array_t;

typedef struct pcc_range_tag {
    size_t start;
    size_t end;
} pcc_range_t;

typedef int pcc_value_t;

typedef void *pcc_auxil_t;

typedef struct pcc_value_table_tag {
    pcc_value_t *buf;
    size_t max;
    size_t len;
} pcc_value_table_t;

typedef struct pcc_value_refer_table_tag {
    pcc_value_t **buf;
    size_t max;
    size_t len;
} pcc_value_refer_table_t;

typedef struct pcc_capture_tag {
    pcc_range_t range;
    char *string; /* mutable */
} pcc_capture_t;

typedef struct pcc_capture_table_tag {
    pcc_capture_t *buf;
    size_t max;
    size_t len;
} pcc_capture_table_t;

typedef struct pcc_capture_const_table_tag {
    const pcc_capture_t **buf;
    size_t max;
    size_t len;
} pcc_capture_const_table_t;

typedef struct pcc_thunk_tag pcc_thunk_t;
typedef struct pcc_thunk_array_tag pcc_thunk_array_t;

typedef void (*pcc_action_t)(llvmir_context_t *, pcc_thunk_t *, pcc_value_t *);

typedef enum pcc_thunk_type_tag {
    PCC_THUNK_LEAF,
    PCC_THUNK_NODE
} pcc_thunk_type_t;

typedef struct pcc_thunk_leaf_tag {
    pcc_value_refer_table_t values;
    pcc_capture_const_table_t capts;
    pcc_capture_t capt0;
    pcc_action_t action;
} pcc_thunk_leaf_t;

typedef struct pcc_thunk_node_tag {
    const pcc_thunk_array_t *thunks; /* just a reference */
    pcc_value_t *value; /* just a reference */
} pcc_thunk_node_t;

typedef union pcc_thunk_data_tag {
    pcc_thunk_leaf_t leaf;
    pcc_thunk_node_t node;
} pcc_thunk_data_t;

struct pcc_thunk_tag {
    pcc_thunk_type_t type;
    pcc_thunk_data_t data;
};

struct pcc_thunk_array_tag {
    pcc_thunk_t **buf;
    size_t max;
    size_t len;
};

typedef struct pcc_thunk_chunk_tag {
    pcc_value_table_t values;
    pcc_capture_table_t capts;
    pcc_thunk_array_t thunks;
    size_t pos; /* the starting position in the character buffer */
} pcc_thunk_chunk_t;

typedef struct pcc_lr_entry_tag pcc_lr_entry_t;

typedef enum pcc_lr_answer_type_tag {
    PCC_LR_ANSWER_LR,
    PCC_LR_ANSWER_CHUNK
} pcc_lr_answer_type_t;

typedef union pcc_lr_answer_data_tag {
    pcc_lr_entry_t *lr;
    pcc_thunk_chunk_t *chunk;
} pcc_lr_answer_data_t;

typedef struct pcc_lr_answer_tag pcc_lr_answer_t;

struct pcc_lr_answer_tag {
    pcc_lr_answer_type_t type;
    pcc_lr_answer_data_t data;
    size_t pos; /* the absolute position in the input */
    pcc_lr_answer_t *hold;
};

typedef pcc_thunk_chunk_t *(*pcc_rule_t)(llvmir_context_t *);

typedef struct pcc_rule_set_tag {
    pcc_rule_t *buf;
    size_t max;
    size_t len;
} pcc_rule_set_t;

typedef struct pcc_lr_head_tag pcc_lr_head_t;

struct pcc_lr_head_tag {
    pcc_rule_t rule;
    pcc_rule_set_t invol;
    pcc_rule_set_t eval;
    pcc_lr_head_t *hold;
};

typedef struct pcc_lr_memo_tag {
    pcc_rule_t rule;
    pcc_lr_answer_t *answer;
} pcc_lr_memo_t;

typedef struct pcc_lr_memo_map_tag {
    pcc_lr_memo_t *buf;
    size_t max;
    size_t len;
} pcc_lr_memo_map_t;

typedef struct pcc_lr_table_entry_tag {
    pcc_lr_head_t *head; /* just a reference */
    pcc_lr_memo_map_t memos;
    pcc_lr_answer_t *hold_a;
    pcc_lr_head_t *hold_h;
} pcc_lr_table_entry_t;

typedef struct pcc_lr_table_tag {
    pcc_lr_table_entry_t **buf;
    size_t max;
    size_t len;
} pcc_lr_table_t;

struct pcc_lr_entry_tag {
    pcc_rule_t rule;
    pcc_thunk_chunk_t *seed; /* just a reference */
    pcc_lr_head_t *head; /* just a reference */
};

typedef struct pcc_lr_stack_tag {
    pcc_lr_entry_t **buf;
    size_t max;
    size_t len;
} pcc_lr_stack_t;

struct llvmir_context_tag {
    size_t pos; /* the position in the input of the first character currently buffered */
    size_t cur; /* the current parsing position in the character buffer */
    size_t level;
    pcc_char_array_t buffer;
    pcc_lr_table_t lrtable;
    pcc_lr_stack_t lrstack;
    pcc_auxil_t auxil;
};

#ifndef PCC_ERROR
#define PCC_ERROR(auxil) pcc_error()
static void pcc_error(void) {
    fprintf(stderr, "Syntax error\n");
    exit(1);
}
#endif /* !PCC_ERROR */

#ifndef PCC_GETCHAR
#define PCC_GETCHAR(auxil) getchar()
#endif /* !PCC_GETCHAR */

#ifndef PCC_MALLOC
#define PCC_MALLOC(auxil, size) pcc_malloc_e(size)
static void *pcc_malloc_e(size_t size) {
    void *const p = malloc(size);
    if (p == NULL) {
        fprintf(stderr, "Out of memory\n");
        exit(1);
    }
    return p;
}
#endif /* !PCC_MALLOC */

#ifndef PCC_REALLOC
#define PCC_REALLOC(auxil, ptr, size) pcc_realloc_e(ptr, size)
static void *pcc_realloc_e(void *ptr, size_t size) {
    void *const p = realloc(ptr, size);
    if (p == NULL) {
        fprintf(stderr, "Out of memory\n");
        exit(1);
    }
    return p;
}
#endif /* !PCC_REALLOC */

#ifndef PCC_FREE
#define PCC_FREE(auxil, ptr) free(ptr)
#endif /* !PCC_FREE */

#ifndef PCC_DEBUG
#define PCC_DEBUG(event, rule, level, pos, buffer, length) ((void)0)
#endif /* !PCC_DEBUG */

static char *pcc_strndup_e(pcc_auxil_t auxil, const char *str, size_t len) {
    const size_t m = strnlen(str, len);
    char *const s = (char *)PCC_MALLOC(auxil, m + 1);
    memcpy(s, str, m);
    s[m] = '\0';
    return s;
}

static void pcc_char_array__init(pcc_auxil_t auxil, pcc_char_array_t *array, size_t max) {
    array->len = 0;
    array->max = max;
    array->buf = (char *)PCC_MALLOC(auxil, array->max);
}

static void pcc_char_array__add(pcc_auxil_t auxil, pcc_char_array_t *array, char ch) {
    if (array->max <= array->len) {
        const size_t n = array->len + 1;
        size_t m = array->max;
        if (m == 0) m = 1;
        while (m < n && m != 0) m <<= 1;
        if (m == 0) m = n;
        array->buf = (char *)PCC_REALLOC(auxil, array->buf, m);
        array->max = m;
    }
    array->buf[array->len++] = ch;
}

static void pcc_char_array__term(pcc_auxil_t auxil, pcc_char_array_t *array) {
    PCC_FREE(auxil, array->buf);
}

static void pcc_value_table__init(pcc_auxil_t auxil, pcc_value_table_t *table, size_t max) {
    table->len = 0;
    table->max = max;
    table->buf = (pcc_value_t *)PCC_MALLOC(auxil, sizeof(pcc_value_t) * table->max);
}

static void pcc_value_table__resize(pcc_auxil_t auxil, pcc_value_table_t *table, size_t len) {
    if (table->max < len) {
        size_t m = table->max;
        if (m == 0) m = 1;
        while (m < len && m != 0) m <<= 1;
        if (m == 0) m = len;
        table->buf = (pcc_value_t *)PCC_REALLOC(auxil, table->buf, sizeof(pcc_value_t) * m);
        table->max = m;
    }
    table->len = len;
}

static void pcc_value_table__term(pcc_auxil_t auxil, pcc_value_table_t *table) {
    PCC_FREE(auxil, table->buf);
}

static void pcc_value_refer_table__init(pcc_auxil_t auxil, pcc_value_refer_table_t *table, size_t max) {
    table->len = 0;
    table->max = max;
    table->buf = (pcc_value_t **)PCC_MALLOC(auxil, sizeof(pcc_value_t *) * table->max);
}

static void pcc_value_refer_table__resize(pcc_auxil_t auxil, pcc_value_refer_table_t *table, size_t len) {
    size_t i;
    if (table->max < len) {
        size_t m = table->max;
        if (m == 0) m = 1;
        while (m < len && m != 0) m <<= 1;
        if (m == 0) m = len;
        table->buf = (pcc_value_t **)PCC_REALLOC(auxil, table->buf, sizeof(pcc_value_t *) * m);
        table->max = m;
    }
    for (i = table->len; i < len; i++) table->buf[i] = NULL;
    table->len = len;
}

static void pcc_value_refer_table__term(pcc_auxil_t auxil, pcc_value_refer_table_t *table) {
    PCC_FREE(auxil, table->buf);
}

static void pcc_capture_table__init(pcc_auxil_t auxil, pcc_capture_table_t *table, size_t max) {
    table->len = 0;
    table->max = max;
    table->buf = (pcc_capture_t *)PCC_MALLOC(auxil, sizeof(pcc_capture_t) * table->max);
}

static void pcc_capture_table__resize(pcc_auxil_t auxil, pcc_capture_table_t *table, size_t len) {
    size_t i;
    for (i = len; i < table->len; i++) PCC_FREE(auxil, table->buf[i].string);
    if (table->max < len) {
        size_t m = table->max;
        if (m == 0) m = 1;
        while (m < len && m != 0) m <<= 1;
        if (m == 0) m = len;
        table->buf = (pcc_capture_t *)PCC_REALLOC(auxil, table->buf, sizeof(pcc_capture_t) * m);
        table->max = m;
    }
    for (i = table->len; i < len; i++) {
        table->buf[i].range.start = 0;
        table->buf[i].range.end = 0;
        table->buf[i].string = NULL;
    }
    table->len = len;
}

static void pcc_capture_table__term(pcc_auxil_t auxil, pcc_capture_table_t *table) {
    while (table->len > 0) {
        table->len--;
        PCC_FREE(auxil, table->buf[table->len].string);
    }
    PCC_FREE(auxil, table->buf);
}

static void pcc_capture_const_table__init(pcc_auxil_t auxil, pcc_capture_const_table_t *table, size_t max) {
    table->len = 0;
    table->max = max;
    table->buf = (const pcc_capture_t **)PCC_MALLOC(auxil, sizeof(const pcc_capture_t *) * table->max);
}

static void pcc_capture_const_table__resize(pcc_auxil_t auxil, pcc_capture_const_table_t *table, size_t len) {
    size_t i;
    if (table->max < len) {
        size_t m = table->max;
        if (m == 0) m = 1;
        while (m < len && m != 0) m <<= 1;
        if (m == 0) m = len;
        table->buf = (const pcc_capture_t **)PCC_REALLOC(auxil, (pcc_capture_t **)table->buf, sizeof(const pcc_capture_t *) * m);
        table->max = m;
    }
    for (i = table->len; i < len; i++) table->buf[i] = NULL;
    table->len = len;
}

static void pcc_capture_const_table__term(pcc_auxil_t auxil, pcc_capture_const_table_t *table) {
    PCC_FREE(auxil, table->buf);
}

static pcc_thunk_t *pcc_thunk__create_leaf(pcc_auxil_t auxil, pcc_action_t action, size_t valuec, size_t captc) {
    pcc_thunk_t *const thunk = (pcc_thunk_t *)PCC_MALLOC(auxil, sizeof(pcc_thunk_t));
    thunk->type = PCC_THUNK_LEAF;
    pcc_value_refer_table__init(auxil, &thunk->data.leaf.values, valuec);
    pcc_value_refer_table__resize(auxil, &thunk->data.leaf.values, valuec);
    pcc_capture_const_table__init(auxil, &thunk->data.leaf.capts, captc);
    pcc_capture_const_table__resize(auxil, &thunk->data.leaf.capts, captc);
    thunk->data.leaf.capt0.range.start = 0;
    thunk->data.leaf.capt0.range.end = 0;
    thunk->data.leaf.capt0.string = NULL;
    thunk->data.leaf.action = action;
    return thunk;
}

static pcc_thunk_t *pcc_thunk__create_node(pcc_auxil_t auxil, const pcc_thunk_array_t *thunks, pcc_value_t *value) {
    pcc_thunk_t *const thunk = (pcc_thunk_t *)PCC_MALLOC(auxil, sizeof(pcc_thunk_t));
    thunk->type = PCC_THUNK_NODE;
    thunk->data.node.thunks = thunks;
    thunk->data.node.value = value;
    return thunk;
}

static void pcc_thunk__destroy(pcc_auxil_t auxil, pcc_thunk_t *thunk) {
    if (thunk == NULL) return;
    switch (thunk->type) {
    case PCC_THUNK_LEAF:
        PCC_FREE(auxil, thunk->data.leaf.capt0.string);
        pcc_capture_const_table__term(auxil, &thunk->data.leaf.capts);
        pcc_value_refer_table__term(auxil, &thunk->data.leaf.values);
        break;
    case PCC_THUNK_NODE:
        break;
    default: /* unknown */
        break;
    }
    PCC_FREE(auxil, thunk);
}

static void pcc_thunk_array__init(pcc_auxil_t auxil, pcc_thunk_array_t *array, size_t max) {
    array->len = 0;
    array->max = max;
    array->buf = (pcc_thunk_t **)PCC_MALLOC(auxil, sizeof(pcc_thunk_t *) * array->max);
}

static void pcc_thunk_array__add(pcc_auxil_t auxil, pcc_thunk_array_t *array, pcc_thunk_t *thunk) {
    if (array->max <= array->len) {
        const size_t n = array->len + 1;
        size_t m = array->max;
        if (m == 0) m = 1;
        while (m < n && m != 0) m <<= 1;
        if (m == 0) m = n;
        array->buf = (pcc_thunk_t **)PCC_REALLOC(auxil, array->buf, sizeof(pcc_thunk_t *) * m);
        array->max = m;
    }
    array->buf[array->len++] = thunk;
}

static void pcc_thunk_array__revert(pcc_auxil_t auxil, pcc_thunk_array_t *array, size_t len) {
    while (array->len > len) {
        array->len--;
        pcc_thunk__destroy(auxil, array->buf[array->len]);
    }
}

static void pcc_thunk_array__term(pcc_auxil_t auxil, pcc_thunk_array_t *array) {
    while (array->len > 0) {
        array->len--;
        pcc_thunk__destroy(auxil, array->buf[array->len]);
    }
    PCC_FREE(auxil, array->buf);
}

static pcc_thunk_chunk_t *pcc_thunk_chunk__create(pcc_auxil_t auxil) {
    pcc_thunk_chunk_t *const chunk = (pcc_thunk_chunk_t *)PCC_MALLOC(auxil, sizeof(pcc_thunk_chunk_t));
    pcc_value_table__init(auxil, &chunk->values, PCC_ARRAYSIZE);
    pcc_capture_table__init(auxil, &chunk->capts, PCC_ARRAYSIZE);
    pcc_thunk_array__init(auxil, &chunk->thunks, PCC_ARRAYSIZE);
    chunk->pos = 0;
    return chunk;
}

static void pcc_thunk_chunk__destroy(pcc_auxil_t auxil, pcc_thunk_chunk_t *chunk) {
    if (chunk == NULL) return;
    pcc_thunk_array__term(auxil, &chunk->thunks);
    pcc_capture_table__term(auxil, &chunk->capts);
    pcc_value_table__term(auxil, &chunk->values);
    PCC_FREE(auxil, chunk);
}

static void pcc_rule_set__init(pcc_auxil_t auxil, pcc_rule_set_t *set, size_t max) {
    set->len = 0;
    set->max = max;
    set->buf = (pcc_rule_t *)PCC_MALLOC(auxil, sizeof(pcc_rule_t) * set->max);
}

static size_t pcc_rule_set__index(pcc_auxil_t auxil, const pcc_rule_set_t *set, pcc_rule_t rule) {
    size_t i;
    for (i = 0; i < set->len; i++) {
        if (set->buf[i] == rule) return i;
    }
    return VOID_VALUE;
}

static pcc_bool_t pcc_rule_set__add(pcc_auxil_t auxil, pcc_rule_set_t *set, pcc_rule_t rule) {
    const size_t i = pcc_rule_set__index(auxil, set, rule);
    if (i != VOID_VALUE) return PCC_FALSE;
    if (set->max <= set->len) {
        const size_t n = set->len + 1;
        size_t m = set->max;
        if (m == 0) m = 1;
        while (m < n && m != 0) m <<= 1;
        if (m == 0) m = n;
        set->buf = (pcc_rule_t *)PCC_REALLOC(auxil, set->buf, sizeof(pcc_rule_t) * m);
        set->max = m;
    }
    set->buf[set->len++] = rule;
    return PCC_TRUE;
}

static pcc_bool_t pcc_rule_set__remove(pcc_auxil_t auxil, pcc_rule_set_t *set, pcc_rule_t rule) {
    const size_t i = pcc_rule_set__index(auxil, set, rule);
    if (i == VOID_VALUE) return PCC_FALSE;
    memmove(set->buf + i, set->buf + (i + 1), sizeof(pcc_rule_t) * (set->len - (i + 1)));
    return PCC_TRUE;
}

static void pcc_rule_set__clear(pcc_auxil_t auxil, pcc_rule_set_t *set) {
    set->len = 0;
}

static void pcc_rule_set__copy(pcc_auxil_t auxil, pcc_rule_set_t *set, const pcc_rule_set_t *src) {
    size_t i;
    pcc_rule_set__clear(auxil, set);
    for (i = 0; i < src->len; i++) {
        pcc_rule_set__add(auxil, set, src->buf[i]);
    }
}

static void pcc_rule_set__term(pcc_auxil_t auxil, pcc_rule_set_t *set) {
    PCC_FREE(auxil, set->buf);
}

static pcc_lr_head_t *pcc_lr_head__create(pcc_auxil_t auxil, pcc_rule_t rule) {
    pcc_lr_head_t *const head = (pcc_lr_head_t *)PCC_MALLOC(auxil, sizeof(pcc_lr_head_t));
    head->rule = rule;
    pcc_rule_set__init(auxil, &head->invol, PCC_ARRAYSIZE);
    pcc_rule_set__init(auxil, &head->eval, PCC_ARRAYSIZE);
    head->hold = NULL;
    return head;
}

static void pcc_lr_head__destroy(pcc_auxil_t auxil, pcc_lr_head_t *head) {
    if (head == NULL) return;
    pcc_lr_head__destroy(auxil, head->hold);
    pcc_rule_set__term(auxil, &head->eval);
    pcc_rule_set__term(auxil, &head->invol);
    PCC_FREE(auxil, head);
}

static void pcc_lr_entry__destroy(pcc_auxil_t auxil, pcc_lr_entry_t *lr);

static pcc_lr_answer_t *pcc_lr_answer__create(pcc_auxil_t auxil, pcc_lr_answer_type_t type, size_t pos) {
    pcc_lr_answer_t *answer = (pcc_lr_answer_t *)PCC_MALLOC(auxil, sizeof(pcc_lr_answer_t));
    answer->type = type;
    answer->pos = pos;
    answer->hold = NULL;
    switch (answer->type) {
    case PCC_LR_ANSWER_LR:
        answer->data.lr = NULL;
        break;
    case PCC_LR_ANSWER_CHUNK:
        answer->data.chunk = NULL;
        break;
    default: /* unknown */
        PCC_FREE(auxil, answer);
        answer = NULL;
    }
    return answer;
}

static void pcc_lr_answer__set_chunk(pcc_auxil_t auxil, pcc_lr_answer_t *answer, pcc_thunk_chunk_t *chunk) {
    pcc_lr_answer_t *const a = pcc_lr_answer__create(auxil, answer->type, answer->pos);
    switch (answer->type) {
    case PCC_LR_ANSWER_LR:
        a->data.lr = answer->data.lr;
        break;
    case PCC_LR_ANSWER_CHUNK:
        a->data.chunk = answer->data.chunk;
        break;
    default: /* unknown */
        break;
    }
    a->hold = answer->hold;
    answer->hold = a;
    answer->type = PCC_LR_ANSWER_CHUNK;
    answer->data.chunk = chunk;
}

static void pcc_lr_answer__destroy(pcc_auxil_t auxil, pcc_lr_answer_t *answer) {
    if (answer == NULL) return;
    pcc_lr_answer__destroy(auxil, answer->hold);
    switch (answer->type) {
    case PCC_LR_ANSWER_LR:
        pcc_lr_entry__destroy(auxil, answer->data.lr);
        break;
    case PCC_LR_ANSWER_CHUNK:
        pcc_thunk_chunk__destroy(auxil, answer->data.chunk);
        break;
    default: /* unknown */
        break;
    }
    PCC_FREE(auxil, answer);
}

static void pcc_lr_memo_map__init(pcc_auxil_t auxil, pcc_lr_memo_map_t *map, size_t max) {
    map->len = 0;
    map->max = max;
    map->buf = (pcc_lr_memo_t *)PCC_MALLOC(auxil, sizeof(pcc_lr_memo_t) * map->max);
}

static size_t pcc_lr_memo_map__index(pcc_auxil_t auxil, pcc_lr_memo_map_t *map, pcc_rule_t rule) {
    size_t i;
    for (i = 0; i < map->len; i++) {
        if (map->buf[i].rule == rule) return i;
    }
    return VOID_VALUE;
}

static void pcc_lr_memo_map__put(pcc_auxil_t auxil, pcc_lr_memo_map_t *map, pcc_rule_t rule, pcc_lr_answer_t *answer) {
    const size_t i = pcc_lr_memo_map__index(auxil, map, rule);
    if (i != VOID_VALUE) {
        pcc_lr_answer__destroy(auxil, map->buf[i].answer);
        map->buf[i].answer = answer;
    }
    else {
        if (map->max <= map->len) {
            const size_t n = map->len + 1;
            size_t m = map->max;
            if (m == 0) m = 1;
            while (m < n && m != 0) m <<= 1;
            if (m == 0) m = n;
            map->buf = (pcc_lr_memo_t *)PCC_REALLOC(auxil, map->buf, sizeof(pcc_lr_memo_t) * m);
            map->max = m;
        }
        map->buf[map->len].rule = rule;
        map->buf[map->len].answer = answer;
        map->len++;
    }
}

static pcc_lr_answer_t *pcc_lr_memo_map__get(pcc_auxil_t auxil, pcc_lr_memo_map_t *map, pcc_rule_t rule) {
    const size_t i = pcc_lr_memo_map__index(auxil, map, rule);
    return (i != VOID_VALUE) ? map->buf[i].answer : NULL;
}

static void pcc_lr_memo_map__term(pcc_auxil_t auxil, pcc_lr_memo_map_t *map) {
    while (map->len > 0) {
        map->len--;
        pcc_lr_answer__destroy(auxil, map->buf[map->len].answer);
    }
    PCC_FREE(auxil, map->buf);
}

static pcc_lr_table_entry_t *pcc_lr_table_entry__create(pcc_auxil_t auxil) {
    pcc_lr_table_entry_t *const entry = (pcc_lr_table_entry_t *)PCC_MALLOC(auxil, sizeof(pcc_lr_table_entry_t));
    entry->head = NULL;
    pcc_lr_memo_map__init(auxil, &entry->memos, PCC_ARRAYSIZE);
    entry->hold_a = NULL;
    entry->hold_h = NULL;
    return entry;
}

static void pcc_lr_table_entry__destroy(pcc_auxil_t auxil, pcc_lr_table_entry_t *entry) {
    if (entry == NULL) return;
    pcc_lr_head__destroy(auxil, entry->hold_h);
    pcc_lr_answer__destroy(auxil, entry->hold_a);
    pcc_lr_memo_map__term(auxil, &entry->memos);
    PCC_FREE(auxil, entry);
}

static void pcc_lr_table__init(pcc_auxil_t auxil, pcc_lr_table_t *table, size_t max) {
    table->len = 0;
    table->max = max;
    table->buf = (pcc_lr_table_entry_t **)PCC_MALLOC(auxil, sizeof(pcc_lr_table_entry_t *) * table->max);
}

static void pcc_lr_table__resize(pcc_auxil_t auxil, pcc_lr_table_t *table, size_t len) {
    size_t i;
    for (i = len; i < table->len; i++) pcc_lr_table_entry__destroy(auxil, table->buf[i]);
    if (table->max < len) {
        size_t m = table->max;
        if (m == 0) m = 1;
        while (m < len && m != 0) m <<= 1;
        if (m == 0) m = len;
        table->buf = (pcc_lr_table_entry_t **)PCC_REALLOC(auxil, table->buf, sizeof(pcc_lr_table_entry_t *) * m);
        table->max = m;
    }
    for (i = table->len; i < len; i++) table->buf[i] = NULL;
    table->len = len;
}

static void pcc_lr_table__set_head(pcc_auxil_t auxil, pcc_lr_table_t *table, size_t index, pcc_lr_head_t *head) {
    if (index >= table->len) pcc_lr_table__resize(auxil, table, index + 1);
    if (table->buf[index] == NULL) table->buf[index] = pcc_lr_table_entry__create(auxil);
    table->buf[index]->head = head;
}

static void pcc_lr_table__hold_head(pcc_auxil_t auxil, pcc_lr_table_t *table, size_t index, pcc_lr_head_t *head) {
    if (index >= table->len) pcc_lr_table__resize(auxil, table, index + 1);
    if (table->buf[index] == NULL) table->buf[index] = pcc_lr_table_entry__create(auxil);
    head->hold = table->buf[index]->hold_h;
    table->buf[index]->hold_h = head;
}

static void pcc_lr_table__set_answer(pcc_auxil_t auxil, pcc_lr_table_t *table, size_t index, pcc_rule_t rule, pcc_lr_answer_t *answer) {
    if (index >= table->len) pcc_lr_table__resize(auxil, table, index + 1);
    if (table->buf[index] == NULL) table->buf[index] = pcc_lr_table_entry__create(auxil);
    pcc_lr_memo_map__put(auxil, &table->buf[index]->memos, rule, answer);
}

static void pcc_lr_table__hold_answer(pcc_auxil_t auxil, pcc_lr_table_t *table, size_t index, pcc_lr_answer_t *answer) {
    if (index >= table->len) pcc_lr_table__resize(auxil, table, index + 1);
    if (table->buf[index] == NULL) table->buf[index] = pcc_lr_table_entry__create(auxil);
    answer->hold = table->buf[index]->hold_a;
    table->buf[index]->hold_a = answer;
}

static pcc_lr_head_t *pcc_lr_table__get_head(pcc_auxil_t auxil, pcc_lr_table_t *table, size_t index) {
    if (index >= table->len || table->buf[index] == NULL) return NULL;
    return table->buf[index]->head;
}

static pcc_lr_answer_t *pcc_lr_table__get_answer(pcc_auxil_t auxil, pcc_lr_table_t *table, size_t index, pcc_rule_t rule) {
    if (index >= table->len || table->buf[index] == NULL) return NULL;
    return pcc_lr_memo_map__get(auxil, &table->buf[index]->memos, rule);
}

static void pcc_lr_table__shift(pcc_auxil_t auxil, pcc_lr_table_t *table, size_t count) {
    size_t i;
    if (count > table->len) count = table->len;
    for (i = 0; i < count; i++) pcc_lr_table_entry__destroy(auxil, table->buf[i]);
    memmove(table->buf, table->buf + count, sizeof(pcc_lr_table_entry_t *) * (table->len - count));
    table->len -= count;
}

static void pcc_lr_table__term(pcc_auxil_t auxil, pcc_lr_table_t *table) {
    while (table->len > 0) {
        table->len--;
        pcc_lr_table_entry__destroy(auxil, table->buf[table->len]);
    }
    PCC_FREE(auxil, table->buf);
}

static pcc_lr_entry_t *pcc_lr_entry__create(pcc_auxil_t auxil, pcc_rule_t rule) {
    pcc_lr_entry_t *const lr = (pcc_lr_entry_t *)PCC_MALLOC(auxil, sizeof(pcc_lr_entry_t));
    lr->rule = rule;
    lr->seed = NULL;
    lr->head = NULL;
    return lr;
}

static void pcc_lr_entry__destroy(pcc_auxil_t auxil, pcc_lr_entry_t *lr) {
    PCC_FREE(auxil, lr);
}

static void pcc_lr_stack__init(pcc_auxil_t auxil, pcc_lr_stack_t *stack, size_t max) {
    stack->len = 0;
    stack->max = max;
    stack->buf = (pcc_lr_entry_t **)PCC_MALLOC(auxil, sizeof(pcc_lr_entry_t *) * stack->max);
}

static void pcc_lr_stack__push(pcc_auxil_t auxil, pcc_lr_stack_t *stack, pcc_lr_entry_t *lr) {
    if (stack->max <= stack->len) {
        const size_t n = stack->len + 1;
        size_t m = stack->max;
        if (m == 0) m = 1;
        while (m < n && m != 0) m <<= 1;
        if (m == 0) m = n;
        stack->buf = (pcc_lr_entry_t **)PCC_REALLOC(auxil, stack->buf, sizeof(pcc_lr_entry_t *) * m);
        stack->max = m;
    }
    stack->buf[stack->len++] = lr;
}

static pcc_lr_entry_t *pcc_lr_stack__pop(pcc_auxil_t auxil, pcc_lr_stack_t *stack) {
    return stack->buf[--stack->len];
}

static void pcc_lr_stack__term(pcc_auxil_t auxil, pcc_lr_stack_t *stack) {
    PCC_FREE(auxil, stack->buf);
}

static llvmir_context_t *pcc_context__create(pcc_auxil_t auxil) {
    llvmir_context_t *const ctx = (llvmir_context_t *)PCC_MALLOC(auxil, sizeof(llvmir_context_t));
    ctx->pos = 0;
    ctx->cur = 0;
    ctx->level = 0;
    pcc_char_array__init(auxil, &ctx->buffer, PCC_BUFFERSIZE);
    pcc_lr_table__init(auxil, &ctx->lrtable, PCC_BUFFERSIZE);
    pcc_lr_stack__init(auxil, &ctx->lrstack, PCC_ARRAYSIZE);
    ctx->auxil = auxil;
    return ctx;
}

static void pcc_context__destroy(llvmir_context_t *ctx) {
    if (ctx == NULL) return;
    pcc_lr_stack__term(ctx->auxil, &ctx->lrstack);
    pcc_lr_table__term(ctx->auxil, &ctx->lrtable);
    pcc_char_array__term(ctx->auxil, &ctx->buffer);
    PCC_FREE(ctx->auxil, ctx);
}

static size_t pcc_refill_buffer(llvmir_context_t *ctx, size_t num) {
    if (ctx->buffer.len >= ctx->cur + num) return ctx->buffer.len - ctx->cur;
    while (ctx->buffer.len < ctx->cur + num) {
        const int c = PCC_GETCHAR(ctx->auxil);
        if (c == EOF) break;
        pcc_char_array__add(ctx->auxil, &ctx->buffer, (char)c);
    }
    return ctx->buffer.len - ctx->cur;
}

static void pcc_commit_buffer(llvmir_context_t *ctx) {
    memmove(ctx->buffer.buf, ctx->buffer.buf + ctx->cur, ctx->buffer.len - ctx->cur);
    ctx->buffer.len -= ctx->cur;
    ctx->pos += ctx->cur;
    pcc_lr_table__shift(ctx->auxil, &ctx->lrtable, ctx->cur);
    ctx->cur = 0;
}

static const char *pcc_get_capture_string(llvmir_context_t *ctx, const pcc_capture_t *capt) {
    if (capt->string == NULL)
        ((pcc_capture_t *)capt)->string =
            pcc_strndup_e(ctx->auxil, ctx->buffer.buf + capt->range.start, capt->range.end - capt->range.start);
    return capt->string;
}

static size_t pcc_get_char_as_utf32(llvmir_context_t *ctx, int *out) { /* with checking UTF-8 validity */
    int c, u;
    size_t n;
    if (pcc_refill_buffer(ctx, 1) < 1) return 0;
    c = (int)(unsigned char)ctx->buffer.buf[ctx->cur];
    n = (c < 0x80) ? 1 :
        ((c & 0xe0) == 0xc0) ? 2 :
        ((c & 0xf0) == 0xe0) ? 3 :
        ((c & 0xf8) == 0xf0) ? 4 : 0;
    if (n < 1) return 0;
    if (pcc_refill_buffer(ctx, n) < n) return 0;
    switch (n) {
    case 1:
        u = c;
        break;
    case 2:
        u = c & 0x1f;
        c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 1];
        if ((c & 0xc0) != 0x80) return 0;
        u <<= 6; u |= c & 0x3f;
        if (u < 0x80) return 0;
        break;
    case 3:
        u = c & 0x0f;
        c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 1];
        if ((c & 0xc0) != 0x80) return 0;
        u <<= 6; u |= c & 0x3f;
        c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 2];
        if ((c & 0xc0) != 0x80) return 0;
        u <<= 6; u |= c & 0x3f;
        if (u < 0x800) return 0;
        break;
    case 4:
        u = c & 0x07;
        c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 1];
        if ((c & 0xc0) != 0x80) return 0;
        u <<= 6; u |= c & 0x3f;
        c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 2];
        if ((c & 0xc0) != 0x80) return 0;
        u <<= 6; u |= c & 0x3f;
        c = (int)(unsigned char)ctx->buffer.buf[ctx->cur + 3];
        if ((c & 0xc0) != 0x80) return 0;
        u <<= 6; u |= c & 0x3f;
        if (u < 0x10000 || u > 0x10ffff) return 0;
        break;
    default:
        return 0;
    }
    if (out) *out = u;
    return n;
}

static pcc_bool_t pcc_apply_rule(llvmir_context_t *ctx, pcc_rule_t rule, pcc_thunk_array_t *thunks, pcc_value_t *value) {
    static pcc_value_t null;
    pcc_thunk_chunk_t *c = NULL;
    const size_t p = ctx->pos + ctx->cur;
    pcc_bool_t b = PCC_TRUE;
    pcc_lr_answer_t *a = pcc_lr_table__get_answer(ctx->auxil, &ctx->lrtable, p, rule);
    pcc_lr_head_t *h = pcc_lr_table__get_head(ctx->auxil, &ctx->lrtable, p);
    if (h != NULL) {
        if (a == NULL && rule != h->rule && pcc_rule_set__index(ctx->auxil, &h->invol, rule) == VOID_VALUE) {
            b = PCC_FALSE;
            c = NULL;
        }
        else if (pcc_rule_set__remove(ctx->auxil, &h->eval, rule)) {
            b = PCC_FALSE;
            c = rule(ctx);
            a = pcc_lr_answer__create(ctx->auxil, PCC_LR_ANSWER_CHUNK, ctx->pos + ctx->cur);
            a->data.chunk = c;
            pcc_lr_table__hold_answer(ctx->auxil, &ctx->lrtable, p, a);
        }
    }
    if (b) {
        if (a != NULL) {
            ctx->cur = a->pos - ctx->pos;
            switch (a->type) {
            case PCC_LR_ANSWER_LR:
                if (a->data.lr->head == NULL) {
                    a->data.lr->head = pcc_lr_head__create(ctx->auxil, rule);
                    pcc_lr_table__hold_head(ctx->auxil, &ctx->lrtable, p, a->data.lr->head);
                }
                {
                    size_t i = ctx->lrstack.len;
                    while (i > 0) {
                        i--;
                        if (ctx->lrstack.buf[i]->head == a->data.lr->head) break;
                        ctx->lrstack.buf[i]->head = a->data.lr->head;
                        pcc_rule_set__add(ctx->auxil, &a->data.lr->head->invol, ctx->lrstack.buf[i]->rule);
                    }
                }
                c = a->data.lr->seed;
                break;
            case PCC_LR_ANSWER_CHUNK:
                c = a->data.chunk;
                break;
            default: /* unknown */
                break;
            }
        }
        else {
            pcc_lr_entry_t *const e = pcc_lr_entry__create(ctx->auxil, rule);
            pcc_lr_stack__push(ctx->auxil, &ctx->lrstack, e);
            a = pcc_lr_answer__create(ctx->auxil, PCC_LR_ANSWER_LR, p);
            a->data.lr = e;
            pcc_lr_table__set_answer(ctx->auxil, &ctx->lrtable, p, rule, a);
            c = rule(ctx);
            pcc_lr_stack__pop(ctx->auxil, &ctx->lrstack);
            a->pos = ctx->pos + ctx->cur;
            if (e->head == NULL) {
                pcc_lr_answer__set_chunk(ctx->auxil, a, c);
            }
            else {
                e->seed = c;
                h = a->data.lr->head;
                if (h->rule != rule) {
                    c = a->data.lr->seed;
                    a = pcc_lr_answer__create(ctx->auxil, PCC_LR_ANSWER_CHUNK, ctx->pos + ctx->cur);
                    a->data.chunk = c;
                    pcc_lr_table__hold_answer(ctx->auxil, &ctx->lrtable, p, a);
                }
                else {
                    pcc_lr_answer__set_chunk(ctx->auxil, a, a->data.lr->seed);
                    if (a->data.chunk == NULL) {
                        c = NULL;
                    }
                    else {
                        pcc_lr_table__set_head(ctx->auxil, &ctx->lrtable, p, h);
                        for (;;) {
                            ctx->cur = p - ctx->pos;
                            pcc_rule_set__copy(ctx->auxil, &h->eval, &h->invol);
                            c = rule(ctx);
                            if (c == NULL || ctx->pos + ctx->cur <= a->pos) break;
                            pcc_lr_answer__set_chunk(ctx->auxil, a, c);
                            a->pos = ctx->pos + ctx->cur;
                        }
                        pcc_thunk_chunk__destroy(ctx->auxil, c);
                        pcc_lr_table__set_head(ctx->auxil, &ctx->lrtable, p, NULL);
                        ctx->cur = a->pos - ctx->pos;
                        c = a->data.chunk;
                    }
                }
            }
        }
    }
    if (c == NULL) return PCC_FALSE;
    if (value == NULL) value = &null;
    memset(value, 0, sizeof(pcc_value_t)); /* in case */
    pcc_thunk_array__add(ctx->auxil, thunks, pcc_thunk__create_node(ctx->auxil, &c->thunks, value));
    return PCC_TRUE;
}

static void pcc_do_action(llvmir_context_t *ctx, const pcc_thunk_array_t *thunks, pcc_value_t *value) {
    size_t i;
    for (i = 0; i < thunks->len; i++) {
        pcc_thunk_t *const thunk = thunks->buf[i];
        switch (thunk->type) {
        case PCC_THUNK_LEAF:
            thunk->data.leaf.action(ctx, thunk, value);
            break;
        case PCC_THUNK_NODE:
            pcc_do_action(ctx, thunk->data.node.thunks, thunk->data.node.value);
            break;
        default: /* unknown */
            break;
        }
    }
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_llvmir(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_lines(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__ascii_letter_upper(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__ascii_letter_lower(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__ascii_letter(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__letter(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__escape_letter(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__decimal_digit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__hex_digit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_comment(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_whitespace(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_endofline(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__name(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__escape_name(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__quoted_name(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__id(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_global_ident(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__global_name(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__global_id(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_local_ident(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__local_name(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__local_id(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_label_ident(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_attr_group_id(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_comdat_name(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_metadata_name(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_metadata_id(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_tag(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_att_encoding(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_di_flag(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_lang(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_cc(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_checksum_kind(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_virtuality(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_macinfo(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_op(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_int_lit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__decimal_lit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__decimals(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_float_lit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__frac_lit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__sign(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__sci_lit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__float_hex_lit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_string_lit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__quoted_string(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule__quoted_stringchar(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_int_type(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TopLevelEntities(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TopLevelEntityList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TopLevelEntity(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SourceFilename(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TargetDefinition(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ModuleAsm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeDef(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ComdatDef(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SelectionKind(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalDecl(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalDef(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptExternallyInitialized(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Immutable(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalAttrs(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalAttrList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalAttr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IndirectSymbolDef(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Alias(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FunctionDecl(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FunctionDef(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FunctionHeader(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptGC(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptPrefix(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptPrologue(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptPersonality(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FunctionBody(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AttrGroupDef(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_NamedMetadataDef(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataNodes(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataNodeList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataNode(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataDef(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptDistinct(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UseListOrders(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UseListOrderList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UseListOrder(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UseListOrderBB(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalIdent(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LocalIdent(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LabelIdent(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AttrGroupID(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ComdatName(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataName(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataID(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Type(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FirstClassType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ConcreteType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_VoidType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FuncType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IntType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FloatType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FloatKind(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MMXType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_PointerType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptAddrSpace(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AddrSpace(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_VectorType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LabelType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TokenType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ArrayType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_StructType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OpaqueType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_NamedType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Value(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_InlineAsm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptSideEffect(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptAlignStack(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptIntelDialect(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Constant(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BoolConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BoolLit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IntConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IntLit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FloatConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_NullConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_NoneConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_StructConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ArrayConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CharArrayConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_StringLit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_VectorConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ZeroInitializerConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UndefConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BlockAddressConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ConstantExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AddExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FAddExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SubExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FSubExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MulExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FMulExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UDivExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SDivExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FDivExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_URemExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SRemExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FRemExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ShlExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LShrExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AShrExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AndExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OrExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_XorExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ExtractElementExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_InsertElementExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ShuffleVectorExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ExtractValueExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_InsertValueExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GetElementPtrExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GEPConstIndices(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GEPConstIndexList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GEPConstIndex(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptInrange(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TruncExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ZExtExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SExtExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FPTruncExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FPExtExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FPToUIExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FPToSIExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UIToFPExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SIToFPExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_PtrToIntExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IntToPtrExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BitCastExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AddrSpaceCastExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ICmpExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FCmpExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SelectExpr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BasicBlockList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BasicBlock(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptLabelIdent(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Instructions(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_InstructionList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Instruction(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ValueInstruction(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AddInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FAddInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SubInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FSubInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MulInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FMulInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UDivInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SDivInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FDivInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_URemInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SRemInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FRemInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ShlInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LShrInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AShrInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AndInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OrInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_XorInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ExtractElementInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_InsertElementInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ShuffleVectorInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ExtractValueInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_InsertValueInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AllocaInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptInAlloca(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptSwiftError(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LoadInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_StoreInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FenceInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CmpXchgInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptWeak(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AtomicRMWInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BinOp(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GetElementPtrInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TruncInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ZExtInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SExtInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FPTruncInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FPExtInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FPToUIInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FPToSIInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UIToFPInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SIToFPInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_PtrToIntInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IntToPtrInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BitCastInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AddrSpaceCastInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ICmpInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FCmpInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_PhiInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IncList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Inc(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SelectInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CallInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptTail(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_VAArgInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LandingPadInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptCleanup(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Clauses(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ClauseList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Clause(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CatchPadInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CleanupPadInst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Terminator(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_RetTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BrTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CondBrTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SwitchTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Cases(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CaseList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Case(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IndirectBrTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LabelList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Label(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_InvokeTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ResumeTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CatchSwitchTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CatchRetTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CleanupRetTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UnreachableTerm(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UnwindTarget(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MDTuple(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MDFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MDFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MDField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Metadata(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MDString(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataAttachment(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MDNode(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataAttachments(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataAttachmentList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptCommaSepMetadataAttachmentList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CommaSepMetadataAttachmentList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SpecializedMDNode(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompileUnit(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompileUnitFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompileUnitFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompileUnitField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFile(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFileFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFileFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFileField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIBasicType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIBasicTypeFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIBasicTypeFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIBasicTypeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubroutineType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubroutineTypeFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubroutineTypeFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubroutineTypeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIDerivedType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIDerivedTypeFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIDerivedTypeFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIDerivedTypeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompositeType(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompositeTypeFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompositeTypeFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompositeTypeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubrange(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubrangeFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubrangeFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubrangeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIEnumerator(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIEnumeratorFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIEnumeratorFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIEnumeratorField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateTypeParameter(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateTypeParameterFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateTypeParameterFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateTypeParameterField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateValueParameter(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateValueParameterFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateValueParameterFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateValueParameterField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIModule(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIModuleFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIModuleFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIModuleField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DINamespace(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DINamespaceFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DINamespaceFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DINamespaceField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariable(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubprogram(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubprogramFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubprogramFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubprogramField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlock(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFile(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFileFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFileFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFileField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocation(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocationFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocationFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocationField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocalVariable(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocalVariableFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocalVariableFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocalVariableField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIExpression(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIExpressionFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIExpressionFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIExpressionField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableExpression(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableExpressionFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableExpressionFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableExpressionField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIObjCProperty(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIObjCPropertyFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIObjCPropertyFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIObjCPropertyField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIImportedEntity(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIImportedEntityFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIImportedEntityFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIImportedEntityField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacro(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFile(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFileFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFileFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFileField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GenericDINode(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GenericDINodeFields(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GenericDINodeFieldList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_GenericDINodeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FileField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IsOptimizedField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TagField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_NameField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_SizeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AlignField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FlagsField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LineField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ScopeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_BaseTypeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OffsetField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TemplateParamsField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IntOrMDField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_LinkageNameField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IsLocalField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IsDefinitionField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DeclarationField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ColumnField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeMacinfoField(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ChecksumKind(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFlagList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFlag(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfAttEncoding(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfCC(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfLang(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfMacinfo(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfOp(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfTag(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfVirtuality(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_EmissionKind(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeValues(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeValueList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CommaSepTypeValueList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeValue(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeConsts(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeConstList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeConst(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Alignment(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AllocSize(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Args(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ArgList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Arg(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_AtomicOrdering(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptCallingConv(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_CallingConv(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptComdat(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Comdat(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Dereferenceable(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptDLLStorageClass(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_DLLStorageClass(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptExact(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ExceptionArgs(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ExceptionArgList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ExceptionArg(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ExceptionScope(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FastMathFlags(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FastMathFlagList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FastMathFlag(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FPred(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FuncAttrs(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FuncAttrList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_FuncAttr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptInBounds(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Indices(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IndexList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Index(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_IPred(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptLinkage(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Linkage(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptExternLinkage(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ExternLinkage(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OperandBundles(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OperandBundleList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OperandBundle(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OverflowFlags(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OverflowFlagList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OverflowFlag(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ParamAttrs(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ParamAttrList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ParamAttr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Params(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ParamList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Param(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptPreemptionSpecifier(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_PreemptionSpecifier(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ReturnAttrs(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ReturnAttrList(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ReturnAttr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptSection(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Section(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_StackAlignment(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptSyncScope(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptThreadLocal(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_ThreadLocal(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_TLSModel(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptUnnamedAddr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_UnnamedAddr(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptVisibility(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_Visibility(llvmir_context_t *ctx);
static pcc_thunk_chunk_t *pcc_evaluate_rule_OptVolatile(llvmir_context_t *ctx);

static pcc_thunk_chunk_t *pcc_evaluate_rule_llvmir(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "llvmir", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_lines, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        {
            int u;
            const size_t n = pcc_get_char_as_utf32(ctx, &u);
            if (n == 0) goto L0001;
            ctx->cur += n;
        }
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "llvmir", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "llvmir", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_lines(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "lines", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule_comment, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule_whitespace, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TopLevelEntities, &chunk->thunks, NULL)) goto L0005;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "lines", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__ascii_letter_upper(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_ascii_letter_upper", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        int u;
        const size_t n = pcc_get_char_as_utf32(ctx, &u);
        if (n == 0) goto L0000;
        if (!(
            (u >= 0x000041 && u <= 0x00005a)
        )) goto L0000;
        ctx->cur += n;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_ascii_letter_upper", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_ascii_letter_upper", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__ascii_letter_lower(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_ascii_letter_lower", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        int u;
        const size_t n = pcc_get_char_as_utf32(ctx, &u);
        if (n == 0) goto L0000;
        if (!(
            (u >= 0x000061 && u <= 0x00007a)
        )) goto L0000;
        ctx->cur += n;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_ascii_letter_lower", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_ascii_letter_lower", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__ascii_letter(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_ascii_letter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter_upper, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter_lower, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_ascii_letter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_ascii_letter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__letter(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_letter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '$'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '-'
        ) goto L0004;
        ctx->cur++;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '.'
        ) goto L0005;
        ctx->cur++;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '_'
        ) goto L0006;
        ctx->cur++;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_letter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_letter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__escape_letter(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_escape_letter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__letter, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\\'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_escape_letter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_escape_letter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__decimal_digit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_decimal_digit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        int u;
        const size_t n = pcc_get_char_as_utf32(ctx, &u);
        if (n == 0) goto L0000;
        if (!(
            (u >= 0x000030 && u <= 0x000039)
        )) goto L0000;
        ctx->cur += n;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_decimal_digit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_decimal_digit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__hex_digit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_hex_digit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        {
            int u;
            const size_t n = pcc_get_char_as_utf32(ctx, &u);
            if (n == 0) goto L0003;
            if (!(
                (u >= 0x000041 && u <= 0x000046)
            )) goto L0003;
            ctx->cur += n;
        }
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        {
            int u;
            const size_t n = pcc_get_char_as_utf32(ctx, &u);
            if (n == 0) goto L0004;
            if (!(
                (u >= 0x000061 && u <= 0x000066)
            )) goto L0004;
            ctx->cur += n;
        }
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_hex_digit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_hex_digit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_comment(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "comment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ';'
    ) goto L0000;
    ctx->cur++;
    {
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule_endofline, &chunk->thunks, NULL)) goto L0002;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            }
            {
                int u;
                const size_t n = pcc_get_char_as_utf32(ctx, &u);
                if (n == 0) goto L0001;
                ctx->cur += n;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_endofline, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "comment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "comment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_whitespace(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "whitespace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                /* unreachable codes omitted */
            }
            if (ctx->cur == p) break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "whitespace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "whitespace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_endofline(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "endofline", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (
                    pcc_refill_buffer(ctx, 2) < 2 ||
                    (ctx->buffer.buf + ctx->cur)[0] != '\r' ||
                    (ctx->buffer.buf + ctx->cur)[1] != '\n'
                ) goto L0003;
                ctx->cur += 2;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '\n'
                ) goto L0004;
                ctx->cur++;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '\r'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 2) < 2 ||
                    (ctx->buffer.buf + ctx->cur)[0] != '\n' ||
                    (ctx->buffer.buf + ctx->cur)[1] != '\r'
                ) goto L0006;
                ctx->cur += 2;
                goto L0002;
            L0006:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "endofline", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "endofline", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__name(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__letter, &chunk->thunks, NULL)) goto L0000;
    {
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__escape_name(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_escape_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__escape_letter, &chunk->thunks, NULL)) goto L0000;
    {
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__escape_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_escape_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_escape_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__quoted_name(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_quoted_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__quoted_string, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_quoted_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_quoted_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__id(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimals, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_global_ident(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "global_ident", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__global_name, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__global_id, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "global_ident", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "global_ident", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__global_name(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_global_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '@'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__name, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__quoted_name, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_global_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_global_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__global_id(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_global_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '@'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__id, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_global_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_global_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_local_ident(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "local_ident", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__local_name, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__local_id, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "local_ident", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "local_ident", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__local_name(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_local_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '%'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__name, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__quoted_name, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_local_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_local_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__local_id(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_local_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '%'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__id, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_local_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_local_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_label_ident(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "label_ident", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule__letter, &chunk->thunks, NULL)) goto L0004;
            goto L0003;
        L0004:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0005;
            goto L0003;
        L0005:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            goto L0002;
        L0003:;
        }
        {
            int i;
            for (i = 0;; i++) {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                {
                    const size_t p = ctx->cur;
                    const size_t n = chunk->thunks.len;
                    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__letter, &chunk->thunks, NULL)) goto L0008;
                    goto L0007;
                L0008:;
                    ctx->cur = p;
                    pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0009;
                    goto L0007;
                L0009:;
                    ctx->cur = p;
                    pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                    goto L0006;
                L0007:;
                }
                if (ctx->cur == p) break;
                continue;
            L0006:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                break;
            }
        }
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ':'
        ) goto L0002;
        ctx->cur++;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__quoted_string, &chunk->thunks, NULL)) goto L0010;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ':'
        ) goto L0010;
        ctx->cur++;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "label_ident", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "label_ident", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_attr_group_id(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "attr_group_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '#'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__id, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "attr_group_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "attr_group_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_comdat_name(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "comdat_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '$'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__name, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__quoted_name, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "comdat_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "comdat_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_metadata_name(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "metadata_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '!'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__escape_name, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "metadata_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "metadata_name", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_metadata_id(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "metadata_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '!'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__id, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "metadata_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "metadata_id", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_tag(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "dwarf_tag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'D'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'W'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'T'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'A'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'G'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '_'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "dwarf_tag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "dwarf_tag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_att_encoding(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "dwarf_att_encoding", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'D'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'W'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'A'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'T'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'E'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '_'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "dwarf_att_encoding", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "dwarf_att_encoding", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_di_flag(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "di_flag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'D'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'I'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'F'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'l'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'a'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'g'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '_'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "di_flag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "di_flag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_lang(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "dwarf_lang", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'D'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'W'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'L'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'A'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'N'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'G'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '_'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "dwarf_lang", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "dwarf_lang", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_cc(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "dwarf_cc", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'D'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'W'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'C'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'C'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '_'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "dwarf_cc", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "dwarf_cc", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_checksum_kind(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "checksum_kind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'C'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'S'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'K'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '_'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "checksum_kind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "checksum_kind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_virtuality(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "dwarf_virtuality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'D'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'W'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'V'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'I'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'R'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'T'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'U'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'A'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'L'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'I'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'T'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'Y'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '_'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "dwarf_virtuality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "dwarf_virtuality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_macinfo(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "dwarf_macinfo", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'D'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'W'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'M'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'A'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'C'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'I'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'N'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'F'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'O'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '_'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "dwarf_macinfo", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "dwarf_macinfo", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_dwarf_op(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "dwarf_op", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'D'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'W'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'O'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'P'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '_'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p0 = ctx->cur;
        const size_t n0 = chunk->thunks.len;
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__ascii_letter, &chunk->thunks, NULL)) goto L0003;
                goto L0002;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0004;
                goto L0002;
            L0004:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                if (
                    pcc_refill_buffer(ctx, 1) < 1 ||
                    ctx->buffer.buf[ctx->cur] != '_'
                ) goto L0005;
                ctx->cur++;
                goto L0002;
            L0005:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                goto L0001;
            L0002:;
            }
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
        if (i < 1) {
            ctx->cur = p0;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
            goto L0000;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "dwarf_op", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "dwarf_op", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_int_lit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "int_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_lit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "int_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "int_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__decimal_lit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_decimal_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '-'
        ) goto L0001;
        ctx->cur++;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimals, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_decimal_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_decimal_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__decimals(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_decimals", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0000;
    {
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0001;
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_decimals", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_decimals", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_float_lit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "float_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__frac_lit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__sci_lit, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__float_hex_lit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "float_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "float_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__frac_lit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_frac_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__sign, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimals, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '.'
    ) goto L0000;
    ctx->cur++;
    {
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimal_digit, &chunk->thunks, NULL)) goto L0003;
            if (ctx->cur == p) break;
            continue;
        L0003:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_frac_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_frac_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__sign(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_sign", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '+'
        ) goto L0002;
        ctx->cur++;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '-'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_sign", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_sign", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__sci_lit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_sci_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__frac_lit, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'e'
        ) goto L0002;
        ctx->cur++;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'E'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__sign, &chunk->thunks, NULL)) goto L0004;
        goto L0005;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0005:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimals, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_sci_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_sci_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__float_hex_lit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_float_hex_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '0'
        ) goto L0002;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'x'
        ) goto L0002;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0002;
        {
            const size_t p0 = ctx->cur;
            const size_t n0 = chunk->thunks.len;
            int i;
            for (i = 0;; i++) {
                const size_t p = ctx->cur;
                const size_t n = chunk->thunks.len;
                if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0003;
                if (ctx->cur == p) break;
                continue;
            L0003:;
                ctx->cur = p;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
                break;
            }
            if (i < 1) {
                ctx->cur = p0;
                pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n0);
                goto L0002;
            }
        }
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '0'
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'x'
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'K'
        ) goto L0004;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '0'
        ) goto L0005;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'x'
        ) goto L0005;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'L'
        ) goto L0005;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '0'
        ) goto L0006;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'x'
        ) goto L0006;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'M'
        ) goto L0006;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '0'
        ) goto L0007;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'x'
        ) goto L0007;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'H'
        ) goto L0007;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0007;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0007;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0007;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule__hex_digit, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_float_hex_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_float_hex_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_string_lit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "string_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__quoted_string, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "string_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "string_lit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__quoted_string(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_quoted_string", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '\"'
    ) goto L0000;
    ctx->cur++;
    {
        int i;
        for (i = 0;; i++) {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule__quoted_stringchar, &chunk->thunks, NULL)) goto L0001;
            if (ctx->cur == p) break;
            continue;
        L0001:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            break;
        }
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '\"'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_quoted_string", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_quoted_string", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule__quoted_stringchar(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "_quoted_stringchar", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\\'
        ) goto L0002;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\"'
        ) goto L0002;
        ctx->cur++;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\\'
        ) goto L0003;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\\'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\\'
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'b'
        ) goto L0004;
        ctx->cur++;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\\'
        ) goto L0005;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'f'
        ) goto L0005;
        ctx->cur++;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\\'
        ) goto L0006;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'n'
        ) goto L0006;
        ctx->cur++;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\\'
        ) goto L0007;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 'r'
        ) goto L0007;
        ctx->cur++;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '\\'
        ) goto L0008;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != 't'
        ) goto L0008;
        ctx->cur++;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (
                pcc_refill_buffer(ctx, 1) < 1 ||
                ctx->buffer.buf[ctx->cur] != '\"'
            ) goto L0010;
            ctx->cur++;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
            goto L0009;
        L0010:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        }
        {
            int u;
            const size_t n = pcc_get_char_as_utf32(ctx, &u);
            if (n == 0) goto L0009;
            ctx->cur += n;
        }
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "_quoted_stringchar", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "_quoted_stringchar", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_int_type(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "int_type", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'i'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule__decimals, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "int_type", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "int_type", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TopLevelEntities(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TopLevelEntities", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TopLevelEntityList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TopLevelEntities", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TopLevelEntities", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TopLevelEntityList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TopLevelEntityList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TopLevelEntity, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TopLevelEntityList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TopLevelEntity, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TopLevelEntityList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TopLevelEntityList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TopLevelEntity(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TopLevelEntity", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SourceFilename, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TargetDefinition, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ModuleAsm, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeDef, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ComdatDef, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalDecl, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalDef, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IndirectSymbolDef, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FunctionDecl, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FunctionDef, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AttrGroupDef, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NamedMetadataDef, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataDef, &chunk->thunks, NULL)) goto L0014;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UseListOrder, &chunk->thunks, NULL)) goto L0015;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UseListOrderBB, &chunk->thunks, NULL)) goto L0016;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TopLevelEntity", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TopLevelEntity", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SourceFilename(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SourceFilename", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 15) < 15 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[6] != '_' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'e'
    ) goto L0000;
    ctx->cur += 15;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '='
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SourceFilename", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SourceFilename", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TargetDefinition(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TargetDefinition", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't'
        ) goto L0002;
        ctx->cur += 6;
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't'
        ) goto L0002;
        ctx->cur += 10;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0002;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't'
        ) goto L0003;
        ctx->cur += 6;
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e'
        ) goto L0003;
        ctx->cur += 6;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TargetDefinition", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TargetDefinition", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ModuleAsm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ModuleAsm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'e'
    ) goto L0000;
    ctx->cur += 6;
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'm'
    ) goto L0000;
    ctx->cur += 3;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ModuleAsm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ModuleAsm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeDef(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0002;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0002;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e'
        ) goto L0002;
        ctx->cur += 4;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OpaqueType, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0003;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e'
        ) goto L0003;
        ctx->cur += 4;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ComdatDef(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ComdatDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ComdatName, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '='
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 't'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SelectionKind, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ComdatDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ComdatDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SelectionKind(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SelectionKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'y'
        ) goto L0002;
        ctx->cur += 3;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'h'
        ) goto L0003;
        ctx->cur += 10;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't'
        ) goto L0004;
        ctx->cur += 7;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[11] != 's'
        ) goto L0005;
        ctx->cur += 12;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e'
        ) goto L0006;
        ctx->cur += 8;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SelectionKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SelectionKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalDecl(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GlobalDecl", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '='
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExternLinkage, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptPreemptionSpecifier, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVisibility, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptDLLStorageClass, &chunk->thunks, NULL)) goto L0005;
        goto L0006;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0006:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptThreadLocal, &chunk->thunks, NULL)) goto L0007;
        goto L0008;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0008:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptUnnamedAddr, &chunk->thunks, NULL)) goto L0009;
        goto L0010;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0010:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptAddrSpace, &chunk->thunks, NULL)) goto L0011;
        goto L0012;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0012:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExternallyInitialized, &chunk->thunks, NULL)) goto L0013;
        goto L0014;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0014:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Immutable, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalAttrs, &chunk->thunks, NULL)) goto L0015;
        goto L0016;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0016:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttrs, &chunk->thunks, NULL)) goto L0017;
        goto L0018;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0018:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GlobalDecl", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GlobalDecl", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalDef(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GlobalDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '='
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptLinkage, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptPreemptionSpecifier, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVisibility, &chunk->thunks, NULL)) goto L0005;
        goto L0006;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0006:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptDLLStorageClass, &chunk->thunks, NULL)) goto L0007;
        goto L0008;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0008:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptThreadLocal, &chunk->thunks, NULL)) goto L0009;
        goto L0010;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0010:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptUnnamedAddr, &chunk->thunks, NULL)) goto L0011;
        goto L0012;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0012:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptAddrSpace, &chunk->thunks, NULL)) goto L0013;
        goto L0014;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0014:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExternallyInitialized, &chunk->thunks, NULL)) goto L0015;
        goto L0016;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0016:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Immutable, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalAttrs, &chunk->thunks, NULL)) goto L0017;
        goto L0018;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0018:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttrs, &chunk->thunks, NULL)) goto L0019;
        goto L0020;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0020:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GlobalDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GlobalDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptExternallyInitialized(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptExternallyInitialized", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 22) < 22 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[10] != '_' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[14] != 't' ||
        (ctx->buffer.buf + ctx->cur)[15] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[16] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[17] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[18] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[19] != 'z' ||
        (ctx->buffer.buf + ctx->cur)[20] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[21] != 'd'
    ) goto L0000;
    ctx->cur += 22;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptExternallyInitialized", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptExternallyInitialized", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Immutable(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Immutable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't'
        ) goto L0002;
        ctx->cur += 8;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l'
        ) goto L0003;
        ctx->cur += 6;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Immutable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Immutable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalAttrs(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GlobalAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalAttrList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GlobalAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GlobalAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalAttrList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GlobalAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalAttr, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalAttrList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalAttr, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GlobalAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GlobalAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalAttr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GlobalAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Section, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Comdat, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataAttachment, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GlobalAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GlobalAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IndirectSymbolDef(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IndirectSymbolDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalIdent, &chunk->thunks, NULL)) goto L0002;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0002;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExternLinkage, &chunk->thunks, NULL)) goto L0002;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptPreemptionSpecifier, &chunk->thunks, NULL)) goto L0003;
            goto L0004;
        L0003:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0004:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVisibility, &chunk->thunks, NULL)) goto L0005;
            goto L0006;
        L0005:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0006:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptDLLStorageClass, &chunk->thunks, NULL)) goto L0007;
            goto L0008;
        L0007:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0008:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptThreadLocal, &chunk->thunks, NULL)) goto L0009;
            goto L0010;
        L0009:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0010:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptUnnamedAddr, &chunk->thunks, NULL)) goto L0011;
            goto L0012;
        L0011:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0012:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alias, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0002;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalIdent, &chunk->thunks, NULL)) goto L0013;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0013;
        ctx->cur++;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptLinkage, &chunk->thunks, NULL)) goto L0014;
            goto L0015;
        L0014:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0015:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptPreemptionSpecifier, &chunk->thunks, NULL)) goto L0016;
            goto L0017;
        L0016:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0017:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVisibility, &chunk->thunks, NULL)) goto L0018;
            goto L0019;
        L0018:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0019:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptDLLStorageClass, &chunk->thunks, NULL)) goto L0020;
            goto L0021;
        L0020:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0021:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptThreadLocal, &chunk->thunks, NULL)) goto L0022;
            goto L0023;
        L0022:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0023:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptUnnamedAddr, &chunk->thunks, NULL)) goto L0024;
            goto L0025;
        L0024:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0025:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alias, &chunk->thunks, NULL)) goto L0013;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0013;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0013;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0013;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IndirectSymbolDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IndirectSymbolDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Alias(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Alias", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's'
        ) goto L0002;
        ctx->cur += 5;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c'
        ) goto L0003;
        ctx->cur += 5;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Alias", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Alias", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FunctionDecl(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FunctionDecl", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e'
    ) goto L0000;
    ctx->cur += 7;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataAttachments, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExternLinkage, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FunctionHeader, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FunctionDecl", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FunctionDecl", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FunctionDef(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FunctionDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'e'
    ) goto L0000;
    ctx->cur += 6;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptLinkage, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FunctionHeader, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataAttachments, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FunctionBody, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FunctionDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FunctionDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FunctionHeader(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FunctionHeader", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptPreemptionSpecifier, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVisibility, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptDLLStorageClass, &chunk->thunks, NULL)) goto L0005;
        goto L0006;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0006:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCallingConv, &chunk->thunks, NULL)) goto L0007;
        goto L0008;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0008:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ReturnAttrs, &chunk->thunks, NULL)) goto L0009;
        goto L0010;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0010:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Params, &chunk->thunks, NULL)) goto L0011;
        goto L0012;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0012:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptUnnamedAddr, &chunk->thunks, NULL)) goto L0013;
        goto L0014;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0014:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttrs, &chunk->thunks, NULL)) goto L0015;
        goto L0016;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0016:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSection, &chunk->thunks, NULL)) goto L0017;
        goto L0018;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0018:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptComdat, &chunk->thunks, NULL)) goto L0019;
        goto L0020;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0020:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptGC, &chunk->thunks, NULL)) goto L0021;
        goto L0022;
    L0021:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0022:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptPrefix, &chunk->thunks, NULL)) goto L0023;
        goto L0024;
    L0023:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0024:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptPrologue, &chunk->thunks, NULL)) goto L0025;
        goto L0026;
    L0025:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0026:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptPersonality, &chunk->thunks, NULL)) goto L0027;
        goto L0028;
    L0027:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0028:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FunctionHeader", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FunctionHeader", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptGC(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptGC", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'c'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptGC", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptGC", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptPrefix(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptPrefix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'x'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptPrefix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptPrefix", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptPrologue(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptPrologue", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e'
    ) goto L0000;
    ctx->cur += 8;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptPrologue", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptPrologue", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptPersonality(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptPersonality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 11) < 11 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[3] != 's' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[9] != 't' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'y'
    ) goto L0000;
    ctx->cur += 11;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptPersonality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptPersonality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FunctionBody(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FunctionBody", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '{'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BasicBlockList, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UseListOrders, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '}'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FunctionBody", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FunctionBody", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AttrGroupDef(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AttrGroupDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 10) < 10 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 't' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[7] != 't' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[9] != 's'
    ) goto L0000;
    ctx->cur += 10;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AttrGroupID, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '='
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '{'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttrs, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '}'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AttrGroupDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AttrGroupDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_NamedMetadataDef(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "NamedMetadataDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataName, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '='
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '!'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '{'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataNodes, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '}'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "NamedMetadataDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "NamedMetadataDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataNodes(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataNodes", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataNodeList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataNodes", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataNodes", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataNodeList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataNodeList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataNode, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataNodeList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataNode, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataNodeList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataNodeList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataNode(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataNode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataID, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIExpression, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataNode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataNode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataDef(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataID, &chunk->thunks, NULL)) goto L0002;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0002;
        ctx->cur++;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptDistinct, &chunk->thunks, NULL)) goto L0003;
            goto L0004;
        L0003:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0004:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDTuple, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataID, &chunk->thunks, NULL)) goto L0005;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0005;
        ctx->cur++;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptDistinct, &chunk->thunks, NULL)) goto L0006;
            goto L0007;
        L0006:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0007:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SpecializedMDNode, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataDef", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptDistinct(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptDistinct", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 's' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[7] != 't'
    ) goto L0000;
    ctx->cur += 8;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptDistinct", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptDistinct", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UseListOrders(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UseListOrders", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UseListOrderList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UseListOrders", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UseListOrders", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UseListOrderList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UseListOrderList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UseListOrder, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UseListOrderList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UseListOrder, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UseListOrderList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UseListOrderList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UseListOrder(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UseListOrder", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 's' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'r'
    ) goto L0000;
    ctx->cur += 12;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '{'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IndexList, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '}'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UseListOrder", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UseListOrder", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UseListOrderBB(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UseListOrderBB", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 15) < 15 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 's' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[12] != '_' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'b'
    ) goto L0000;
    ctx->cur += 15;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '{'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IndexList, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '}'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UseListOrderBB", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UseListOrderBB", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GlobalIdent(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GlobalIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_global_ident, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GlobalIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GlobalIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LocalIdent(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LocalIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_local_ident, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LocalIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LocalIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LabelIdent(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LabelIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_label_ident, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LabelIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LabelIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AttrGroupID(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AttrGroupID", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_attr_group_id, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AttrGroupID", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AttrGroupID", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ComdatName(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ComdatName", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_comdat_name, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ComdatName", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ComdatName", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataName(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataName", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_metadata_name, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataName", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataName", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataID(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataID", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_metadata_id, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataID", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataID", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Type(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Type", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_VoidType, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncType, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FirstClassType, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Type", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Type", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FirstClassType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FirstClassType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ConcreteType, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataType, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FirstClassType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FirstClassType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ConcreteType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ConcreteType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntType, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FloatType, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_PointerType, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_VectorType, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ArrayType, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StructType, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NamedType, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MMXType, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TokenType, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ConcreteType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ConcreteType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_VoidType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "VoidType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'd'
    ) goto L0000;
    ctx->cur += 4;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "VoidType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "VoidType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FuncType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FuncType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Params, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FuncType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FuncType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IntType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IntType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_type, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IntType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IntType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FloatType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FloatType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FloatKind, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FloatType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FloatType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FloatKind(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FloatKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'f'
        ) goto L0002;
        ctx->cur += 4;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't'
        ) goto L0003;
        ctx->cur += 5;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e'
        ) goto L0004;
        ctx->cur += 6;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != '8' ||
            (ctx->buffer.buf + ctx->cur)[2] != '6' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[6] != '8' ||
            (ctx->buffer.buf + ctx->cur)[7] != '0'
        ) goto L0005;
        ctx->cur += 8;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != '1' ||
            (ctx->buffer.buf + ctx->cur)[3] != '2' ||
            (ctx->buffer.buf + ctx->cur)[4] != '8'
        ) goto L0006;
        ctx->cur += 5;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[6] != '1' ||
            (ctx->buffer.buf + ctx->cur)[7] != '2' ||
            (ctx->buffer.buf + ctx->cur)[8] != '8'
        ) goto L0007;
        ctx->cur += 9;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FloatKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FloatKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MMXType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MMXType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[1] != '8' ||
        (ctx->buffer.buf + ctx->cur)[2] != '6' ||
        (ctx->buffer.buf + ctx->cur)[3] != '_' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'x'
    ) goto L0000;
    ctx->cur += 7;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MMXType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MMXType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_PointerType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "PointerType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptAddrSpace, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '*'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "PointerType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "PointerType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptAddrSpace(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptAddrSpace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AddrSpace, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptAddrSpace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptAddrSpace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AddrSpace(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AddrSpace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 9) < 9 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 's' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e'
    ) goto L0000;
    ctx->cur += 9;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AddrSpace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AddrSpace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_VectorType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "VectorType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '<'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'x'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '>'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "VectorType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "VectorType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LabelType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LabelType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'l'
    ) goto L0000;
    ctx->cur += 5;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LabelType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LabelType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TokenType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TokenType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'k' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n'
    ) goto L0000;
    ctx->cur += 5;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TokenType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TokenType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a'
    ) goto L0000;
    ctx->cur += 8;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ArrayType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ArrayType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '['
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'x'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ']'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ArrayType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ArrayType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_StructType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "StructType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0002;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0002;
        ctx->cur++;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '<'
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '>'
        ) goto L0004;
        ctx->cur++;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '<'
        ) goto L0005;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0005;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeList, &chunk->thunks, NULL)) goto L0005;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0005;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '>'
        ) goto L0005;
        ctx->cur++;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "StructType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "StructType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OpaqueType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OpaqueType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'q' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'e'
    ) goto L0000;
    ctx->cur += 6;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OpaqueType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OpaqueType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_NamedType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "NamedType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "NamedType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "NamedType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Value(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Value", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_InlineAsm, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Value", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Value", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_InlineAsm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "InlineAsm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'm'
    ) goto L0000;
    ctx->cur += 3;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSideEffect, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptAlignStack, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptIntelDialect, &chunk->thunks, NULL)) goto L0005;
        goto L0006;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0006:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "InlineAsm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "InlineAsm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptSideEffect(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptSideEffect", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 10) < 10 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[9] != 't'
    ) goto L0000;
    ctx->cur += 10;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptSideEffect", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptSideEffect", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptAlignStack(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptAlignStack", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 10) < 10 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 's' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'k'
    ) goto L0000;
    ctx->cur += 10;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptAlignStack", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptAlignStack", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptIntelDialect(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptIntelDialect", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[11] != 't'
    ) goto L0000;
    ctx->cur += 12;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptIntelDialect", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptIntelDialect", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Constant(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Constant", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolConst, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntConst, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FloatConst, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NullConst, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NoneConst, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StructConst, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ArrayConst, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CharArrayConst, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_VectorConst, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ZeroInitializerConst, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalIdent, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UndefConst, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BlockAddressConst, &chunk->thunks, NULL)) goto L0014;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ConstantExpr, &chunk->thunks, NULL)) goto L0015;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Constant", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Constant", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BoolConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BoolConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BoolConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BoolConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BoolLit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BoolLit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e'
        ) goto L0002;
        ctx->cur += 4;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e'
        ) goto L0003;
        ctx->cur += 5;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BoolLit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BoolLit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IntConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IntConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IntConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IntConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IntLit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IntLit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IntLit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IntLit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FloatConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FloatConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_float_lit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FloatConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FloatConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_NullConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "NullConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l'
    ) goto L0000;
    ctx->cur += 4;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "NullConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "NullConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_NoneConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "NoneConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e'
    ) goto L0000;
    ctx->cur += 4;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "NoneConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "NoneConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_StructConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "StructConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0002;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0002;
        ctx->cur++;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeConstList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '<'
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '>'
        ) goto L0004;
        ctx->cur++;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '<'
        ) goto L0005;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0005;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeConstList, &chunk->thunks, NULL)) goto L0005;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0005;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '>'
        ) goto L0005;
        ctx->cur++;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "StructConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "StructConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ArrayConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ArrayConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '['
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeConsts, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ']'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ArrayConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ArrayConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CharArrayConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CharArrayConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != 'c'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CharArrayConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CharArrayConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_StringLit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "StringLit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_string_lit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "StringLit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "StringLit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_VectorConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "VectorConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '<'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeConsts, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '>'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "VectorConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "VectorConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ZeroInitializerConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ZeroInitializerConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 15) < 15 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'z' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[7] != 't' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'z' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'r'
    ) goto L0000;
    ctx->cur += 15;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ZeroInitializerConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ZeroInitializerConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UndefConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UndefConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'f'
    ) goto L0000;
    ctx->cur += 5;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UndefConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UndefConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BlockAddressConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BlockAddressConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'k' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[10] != 's' ||
        (ctx->buffer.buf + ctx->cur)[11] != 's'
    ) goto L0000;
    ctx->cur += 12;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GlobalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BlockAddressConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BlockAddressConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ConstantExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ConstantExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AddExpr, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FAddExpr, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SubExpr, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FSubExpr, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MulExpr, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FMulExpr, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UDivExpr, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SDivExpr, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FDivExpr, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_URemExpr, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SRemExpr, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FRemExpr, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ShlExpr, &chunk->thunks, NULL)) goto L0014;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LShrExpr, &chunk->thunks, NULL)) goto L0015;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AShrExpr, &chunk->thunks, NULL)) goto L0016;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AndExpr, &chunk->thunks, NULL)) goto L0017;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OrExpr, &chunk->thunks, NULL)) goto L0018;
        goto L0001;
    L0018:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_XorExpr, &chunk->thunks, NULL)) goto L0019;
        goto L0001;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExtractElementExpr, &chunk->thunks, NULL)) goto L0020;
        goto L0001;
    L0020:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_InsertElementExpr, &chunk->thunks, NULL)) goto L0021;
        goto L0001;
    L0021:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ShuffleVectorExpr, &chunk->thunks, NULL)) goto L0022;
        goto L0001;
    L0022:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExtractValueExpr, &chunk->thunks, NULL)) goto L0023;
        goto L0001;
    L0023:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_InsertValueExpr, &chunk->thunks, NULL)) goto L0024;
        goto L0001;
    L0024:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GetElementPtrExpr, &chunk->thunks, NULL)) goto L0025;
        goto L0001;
    L0025:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TruncExpr, &chunk->thunks, NULL)) goto L0026;
        goto L0001;
    L0026:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ZExtExpr, &chunk->thunks, NULL)) goto L0027;
        goto L0001;
    L0027:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SExtExpr, &chunk->thunks, NULL)) goto L0028;
        goto L0001;
    L0028:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPTruncExpr, &chunk->thunks, NULL)) goto L0029;
        goto L0001;
    L0029:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPExtExpr, &chunk->thunks, NULL)) goto L0030;
        goto L0001;
    L0030:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPToUIExpr, &chunk->thunks, NULL)) goto L0031;
        goto L0001;
    L0031:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPToSIExpr, &chunk->thunks, NULL)) goto L0032;
        goto L0001;
    L0032:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UIToFPExpr, &chunk->thunks, NULL)) goto L0033;
        goto L0001;
    L0033:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SIToFPExpr, &chunk->thunks, NULL)) goto L0034;
        goto L0001;
    L0034:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_PtrToIntExpr, &chunk->thunks, NULL)) goto L0035;
        goto L0001;
    L0035:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntToPtrExpr, &chunk->thunks, NULL)) goto L0036;
        goto L0001;
    L0036:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BitCastExpr, &chunk->thunks, NULL)) goto L0037;
        goto L0001;
    L0037:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AddrSpaceCastExpr, &chunk->thunks, NULL)) goto L0038;
        goto L0001;
    L0038:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ICmpExpr, &chunk->thunks, NULL)) goto L0039;
        goto L0001;
    L0039:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FCmpExpr, &chunk->thunks, NULL)) goto L0040;
        goto L0001;
    L0040:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SelectExpr, &chunk->thunks, NULL)) goto L0041;
        goto L0001;
    L0041:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ConstantExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ConstantExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AddExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AddExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd'
    ) goto L0000;
    ctx->cur += 3;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AddExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AddExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FAddExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FAddExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'd'
    ) goto L0000;
    ctx->cur += 4;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FAddExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FAddExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SubExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SubExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'b'
    ) goto L0000;
    ctx->cur += 3;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SubExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SubExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FSubExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FSubExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'b'
    ) goto L0000;
    ctx->cur += 4;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FSubExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FSubExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MulExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MulExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l'
    ) goto L0000;
    ctx->cur += 3;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MulExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MulExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FMulExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FMulExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l'
    ) goto L0000;
    ctx->cur += 4;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FMulExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FMulExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UDivExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UDivExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'v'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExact, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UDivExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UDivExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SDivExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SDivExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'v'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExact, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SDivExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SDivExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FDivExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FDivExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'v'
    ) goto L0000;
    ctx->cur += 4;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FDivExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FDivExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_URemExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "URemExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'm'
    ) goto L0000;
    ctx->cur += 4;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "URemExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "URemExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SRemExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SRemExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'm'
    ) goto L0000;
    ctx->cur += 4;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SRemExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SRemExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FRemExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FRemExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'm'
    ) goto L0000;
    ctx->cur += 4;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FRemExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FRemExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ShlExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ShlExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l'
    ) goto L0000;
    ctx->cur += 3;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ShlExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ShlExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LShrExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LShrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExact, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LShrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LShrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AShrExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AShrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExact, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AShrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AShrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AndExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AndExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd'
    ) goto L0000;
    ctx->cur += 3;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AndExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AndExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OrExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r'
    ) goto L0000;
    ctx->cur += 2;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_XorExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "XorExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'r'
    ) goto L0000;
    ctx->cur += 3;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "XorExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "XorExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ExtractElementExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ExtractElementExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 14) < 14 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[13] != 't'
    ) goto L0000;
    ctx->cur += 14;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ExtractElementExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ExtractElementExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_InsertElementExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "InsertElementExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 's' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[5] != 't' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[12] != 't'
    ) goto L0000;
    ctx->cur += 13;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "InsertElementExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "InsertElementExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ShuffleVectorExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ShuffleVectorExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[10] != 't' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'r'
    ) goto L0000;
    ctx->cur += 13;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ShuffleVectorExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ShuffleVectorExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ExtractValueExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ExtractValueExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'e'
    ) goto L0000;
    ctx->cur += 12;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Indices, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ExtractValueExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ExtractValueExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_InsertValueExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "InsertValueExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 11) < 11 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 's' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[5] != 't' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e'
    ) goto L0000;
    ctx->cur += 11;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Indices, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "InsertValueExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "InsertValueExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GetElementPtrExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GetElementPtrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[9] != 't' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[11] != 't' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'r'
    ) goto L0000;
    ctx->cur += 13;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInBounds, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GEPConstIndices, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GetElementPtrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GetElementPtrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GEPConstIndices(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GEPConstIndices", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GEPConstIndexList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GEPConstIndices", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GEPConstIndices", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GEPConstIndexList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GEPConstIndexList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GEPConstIndex, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GEPConstIndexList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GEPConstIndex, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GEPConstIndexList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GEPConstIndexList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GEPConstIndex(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GEPConstIndex", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInrange, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GEPConstIndex", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GEPConstIndex", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptInrange(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptInrange", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e'
    ) goto L0000;
    ctx->cur += 7;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptInrange", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptInrange", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TruncExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TruncExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'c'
    ) goto L0000;
    ctx->cur += 5;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TruncExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TruncExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ZExtExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ZExtExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'z' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't'
    ) goto L0000;
    ctx->cur += 4;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ZExtExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ZExtExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SExtExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SExtExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't'
    ) goto L0000;
    ctx->cur += 4;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SExtExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SExtExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FPTruncExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FPTruncExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'c'
    ) goto L0000;
    ctx->cur += 7;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FPTruncExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FPTruncExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FPExtExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FPExtExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[4] != 't'
    ) goto L0000;
    ctx->cur += 5;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FPExtExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FPExtExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FPToUIExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FPToUIExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'i'
    ) goto L0000;
    ctx->cur += 6;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FPToUIExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FPToUIExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FPToSIExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FPToSIExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 's' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'i'
    ) goto L0000;
    ctx->cur += 6;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FPToSIExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FPToSIExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UIToFPExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UIToFPExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p'
    ) goto L0000;
    ctx->cur += 6;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UIToFPExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UIToFPExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SIToFPExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SIToFPExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p'
    ) goto L0000;
    ctx->cur += 6;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SIToFPExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SIToFPExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_PtrToIntExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "PtrToIntExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[1] != 't' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[7] != 't'
    ) goto L0000;
    ctx->cur += 8;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "PtrToIntExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "PtrToIntExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IntToPtrExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IntToPtrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'r'
    ) goto L0000;
    ctx->cur += 8;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IntToPtrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IntToPtrExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BitCastExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BitCastExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 's' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't'
    ) goto L0000;
    ctx->cur += 7;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BitCastExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BitCastExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AddrSpaceCastExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AddrSpaceCastExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 's' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[11] != 's' ||
        (ctx->buffer.buf + ctx->cur)[12] != 't'
    ) goto L0000;
    ctx->cur += 13;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AddrSpaceCastExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AddrSpaceCastExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ICmpExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ICmpExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'p'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IPred, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ICmpExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ICmpExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FCmpExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FCmpExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'p'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPred, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FCmpExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FCmpExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SelectExpr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SelectExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[5] != 't'
    ) goto L0000;
    ctx->cur += 6;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SelectExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SelectExpr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BasicBlockList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BasicBlockList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BasicBlock, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BasicBlockList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BasicBlock, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BasicBlockList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BasicBlockList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BasicBlock(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BasicBlock", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptLabelIdent, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Instructions, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Terminator, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BasicBlock", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BasicBlock", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptLabelIdent(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptLabelIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelIdent, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptLabelIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptLabelIdent", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Instructions(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Instructions", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_InstructionList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Instructions", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Instructions", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_InstructionList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "InstructionList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Instruction, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_InstructionList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Instruction, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "InstructionList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "InstructionList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Instruction(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Instruction", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StoreInst, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FenceInst, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CmpXchgInst, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AtomicRMWInst, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0006;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0006;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ValueInstruction, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ValueInstruction, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Instruction", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Instruction", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ValueInstruction(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ValueInstruction", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AddInst, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FAddInst, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SubInst, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FSubInst, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MulInst, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FMulInst, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UDivInst, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SDivInst, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FDivInst, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_URemInst, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SRemInst, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FRemInst, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ShlInst, &chunk->thunks, NULL)) goto L0014;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LShrInst, &chunk->thunks, NULL)) goto L0015;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AShrInst, &chunk->thunks, NULL)) goto L0016;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AndInst, &chunk->thunks, NULL)) goto L0017;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OrInst, &chunk->thunks, NULL)) goto L0018;
        goto L0001;
    L0018:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_XorInst, &chunk->thunks, NULL)) goto L0019;
        goto L0001;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExtractElementInst, &chunk->thunks, NULL)) goto L0020;
        goto L0001;
    L0020:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_InsertElementInst, &chunk->thunks, NULL)) goto L0021;
        goto L0001;
    L0021:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ShuffleVectorInst, &chunk->thunks, NULL)) goto L0022;
        goto L0001;
    L0022:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExtractValueInst, &chunk->thunks, NULL)) goto L0023;
        goto L0001;
    L0023:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_InsertValueInst, &chunk->thunks, NULL)) goto L0024;
        goto L0001;
    L0024:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AllocaInst, &chunk->thunks, NULL)) goto L0025;
        goto L0001;
    L0025:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LoadInst, &chunk->thunks, NULL)) goto L0026;
        goto L0001;
    L0026:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GetElementPtrInst, &chunk->thunks, NULL)) goto L0027;
        goto L0001;
    L0027:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TruncInst, &chunk->thunks, NULL)) goto L0028;
        goto L0001;
    L0028:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ZExtInst, &chunk->thunks, NULL)) goto L0029;
        goto L0001;
    L0029:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SExtInst, &chunk->thunks, NULL)) goto L0030;
        goto L0001;
    L0030:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPTruncInst, &chunk->thunks, NULL)) goto L0031;
        goto L0001;
    L0031:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPExtInst, &chunk->thunks, NULL)) goto L0032;
        goto L0001;
    L0032:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPToUIInst, &chunk->thunks, NULL)) goto L0033;
        goto L0001;
    L0033:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPToSIInst, &chunk->thunks, NULL)) goto L0034;
        goto L0001;
    L0034:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UIToFPInst, &chunk->thunks, NULL)) goto L0035;
        goto L0001;
    L0035:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SIToFPInst, &chunk->thunks, NULL)) goto L0036;
        goto L0001;
    L0036:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_PtrToIntInst, &chunk->thunks, NULL)) goto L0037;
        goto L0001;
    L0037:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntToPtrInst, &chunk->thunks, NULL)) goto L0038;
        goto L0001;
    L0038:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BitCastInst, &chunk->thunks, NULL)) goto L0039;
        goto L0001;
    L0039:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AddrSpaceCastInst, &chunk->thunks, NULL)) goto L0040;
        goto L0001;
    L0040:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ICmpInst, &chunk->thunks, NULL)) goto L0041;
        goto L0001;
    L0041:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FCmpInst, &chunk->thunks, NULL)) goto L0042;
        goto L0001;
    L0042:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_PhiInst, &chunk->thunks, NULL)) goto L0043;
        goto L0001;
    L0043:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SelectInst, &chunk->thunks, NULL)) goto L0044;
        goto L0001;
    L0044:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CallInst, &chunk->thunks, NULL)) goto L0045;
        goto L0001;
    L0045:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_VAArgInst, &chunk->thunks, NULL)) goto L0046;
        goto L0001;
    L0046:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LandingPadInst, &chunk->thunks, NULL)) goto L0047;
        goto L0001;
    L0047:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CatchPadInst, &chunk->thunks, NULL)) goto L0048;
        goto L0001;
    L0048:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CleanupPadInst, &chunk->thunks, NULL)) goto L0049;
        goto L0001;
    L0049:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ValueInstruction", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ValueInstruction", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AddInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AddInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd'
    ) goto L0000;
    ctx->cur += 3;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AddInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AddInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FAddInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FAddInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'd'
    ) goto L0000;
    ctx->cur += 4;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FAddInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FAddInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SubInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SubInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'b'
    ) goto L0000;
    ctx->cur += 3;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SubInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SubInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FSubInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FSubInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'b'
    ) goto L0000;
    ctx->cur += 4;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FSubInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FSubInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MulInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MulInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l'
    ) goto L0000;
    ctx->cur += 3;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MulInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MulInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FMulInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FMulInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l'
    ) goto L0000;
    ctx->cur += 4;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FMulInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FMulInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UDivInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UDivInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'v'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExact, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UDivInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UDivInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SDivInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SDivInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'v'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExact, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SDivInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SDivInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FDivInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FDivInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'v'
    ) goto L0000;
    ctx->cur += 4;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FDivInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FDivInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_URemInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "URemInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'm'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "URemInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "URemInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SRemInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SRemInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'm'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SRemInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SRemInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FRemInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FRemInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'm'
    ) goto L0000;
    ctx->cur += 4;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FRemInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FRemInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ShlInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ShlInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l'
    ) goto L0000;
    ctx->cur += 3;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ShlInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ShlInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LShrInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LShrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExact, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LShrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LShrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AShrInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AShrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptExact, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AShrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AShrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AndInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AndInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd'
    ) goto L0000;
    ctx->cur += 3;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AndInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AndInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OrInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_XorInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "XorInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'r'
    ) goto L0000;
    ctx->cur += 3;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "XorInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "XorInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ExtractElementInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ExtractElementInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 14) < 14 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[13] != 't'
    ) goto L0000;
    ctx->cur += 14;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ExtractElementInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ExtractElementInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_InsertElementInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "InsertElementInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 's' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[5] != 't' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[12] != 't'
    ) goto L0000;
    ctx->cur += 13;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "InsertElementInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "InsertElementInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ShuffleVectorInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ShuffleVectorInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[10] != 't' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'r'
    ) goto L0000;
    ctx->cur += 13;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ShuffleVectorInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ShuffleVectorInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ExtractValueInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ExtractValueInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'e'
    ) goto L0000;
    ctx->cur += 12;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IndexList, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ExtractValueInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ExtractValueInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_InsertValueInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "InsertValueInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 11) < 11 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 's' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[5] != 't' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e'
    ) goto L0000;
    ctx->cur += 11;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IndexList, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "InsertValueInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "InsertValueInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AllocaInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AllocaInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a'
        ) goto L0002;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInAlloca, &chunk->thunks, NULL)) goto L0003;
            goto L0004;
        L0003:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0004:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSwiftError, &chunk->thunks, NULL)) goto L0005;
            goto L0006;
        L0005:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0006:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0007;
            goto L0008;
        L0007:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0008:;
        }
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a'
        ) goto L0009;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInAlloca, &chunk->thunks, NULL)) goto L0010;
            goto L0011;
        L0010:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0011:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSwiftError, &chunk->thunks, NULL)) goto L0012;
            goto L0013;
        L0012:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0013:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0009;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0009;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0009;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0014;
            goto L0015;
        L0014:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0015:;
        }
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a'
        ) goto L0016;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInAlloca, &chunk->thunks, NULL)) goto L0017;
            goto L0018;
        L0017:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0018:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSwiftError, &chunk->thunks, NULL)) goto L0019;
            goto L0020;
        L0019:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0020:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0016;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0016;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0016;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0016;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0021;
            goto L0022;
        L0021:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0022:;
        }
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a'
        ) goto L0023;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInAlloca, &chunk->thunks, NULL)) goto L0024;
            goto L0025;
        L0024:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0025:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSwiftError, &chunk->thunks, NULL)) goto L0026;
            goto L0027;
        L0026:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0027:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0023;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0023;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0023;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0023;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0023;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0023;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0028;
            goto L0029;
        L0028:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0029:;
        }
        goto L0001;
    L0023:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a'
        ) goto L0030;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInAlloca, &chunk->thunks, NULL)) goto L0031;
            goto L0032;
        L0031:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0032:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSwiftError, &chunk->thunks, NULL)) goto L0033;
            goto L0034;
        L0033:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0034:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0030;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0030;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AddrSpace, &chunk->thunks, NULL)) goto L0030;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0035;
            goto L0036;
        L0035:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0036:;
        }
        goto L0001;
    L0030:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a'
        ) goto L0037;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInAlloca, &chunk->thunks, NULL)) goto L0038;
            goto L0039;
        L0038:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0039:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSwiftError, &chunk->thunks, NULL)) goto L0040;
            goto L0041;
        L0040:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0041:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0037;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0037;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0037;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0037;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AddrSpace, &chunk->thunks, NULL)) goto L0037;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0042;
            goto L0043;
        L0042:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0043:;
        }
        goto L0001;
    L0037:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a'
        ) goto L0044;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInAlloca, &chunk->thunks, NULL)) goto L0045;
            goto L0046;
        L0045:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0046:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSwiftError, &chunk->thunks, NULL)) goto L0047;
            goto L0048;
        L0047:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0048:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0044;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0044;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0044;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0044;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0044;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AddrSpace, &chunk->thunks, NULL)) goto L0044;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0049;
            goto L0050;
        L0049:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0050:;
        }
        goto L0001;
    L0044:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a'
        ) goto L0051;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInAlloca, &chunk->thunks, NULL)) goto L0052;
            goto L0053;
        L0052:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0053:;
        }
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSwiftError, &chunk->thunks, NULL)) goto L0054;
            goto L0055;
        L0054:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0055:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0051;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0051;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0051;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0051;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0051;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0051;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0051;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AddrSpace, &chunk->thunks, NULL)) goto L0051;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0056;
            goto L0057;
        L0056:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0057:;
        }
        goto L0001;
    L0051:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AllocaInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AllocaInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptInAlloca(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptInAlloca", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a'
    ) goto L0000;
    ctx->cur += 8;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptInAlloca", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptInAlloca", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptSwiftError(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptSwiftError", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 10) < 10 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[4] != 't' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'r'
    ) goto L0000;
    ctx->cur += 10;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptSwiftError", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptSwiftError", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LoadInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LoadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd'
        ) goto L0002;
        ctx->cur += 4;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0003;
            goto L0004;
        L0003:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0004:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0002;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0002;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0005;
            goto L0006;
        L0005:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0006:;
        }
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd'
        ) goto L0007;
        ctx->cur += 4;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0008;
            goto L0009;
        L0008:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0009:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0007;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0007;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0007;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0007;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0007;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0007;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0010;
            goto L0011;
        L0010:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0011:;
        }
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd'
        ) goto L0012;
        ctx->cur += 4;
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c'
        ) goto L0012;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0013;
            goto L0014;
        L0013:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0014:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0012;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0012;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0012;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0012;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSyncScope, &chunk->thunks, NULL)) goto L0015;
            goto L0016;
        L0015:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0016:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AtomicOrdering, &chunk->thunks, NULL)) goto L0012;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0017;
            goto L0018;
        L0017:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0018:;
        }
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd'
        ) goto L0019;
        ctx->cur += 4;
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c'
        ) goto L0019;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0020;
            goto L0021;
        L0020:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0021:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0019;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0019;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0019;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0019;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSyncScope, &chunk->thunks, NULL)) goto L0022;
            goto L0023;
        L0022:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0023:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AtomicOrdering, &chunk->thunks, NULL)) goto L0019;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0019;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0019;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0024;
            goto L0025;
        L0024:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0025:;
        }
        goto L0001;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LoadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LoadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_StoreInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "StoreInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e'
        ) goto L0002;
        ctx->cur += 5;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0003;
            goto L0004;
        L0003:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0004:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0002;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0002;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0002;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0005;
            goto L0006;
        L0005:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0006:;
        }
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e'
        ) goto L0007;
        ctx->cur += 5;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0008;
            goto L0009;
        L0008:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0009:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0007;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0007;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0007;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0007;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0007;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0007;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0007;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0010;
            goto L0011;
        L0010:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0011:;
        }
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e'
        ) goto L0012;
        ctx->cur += 5;
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c'
        ) goto L0012;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0013;
            goto L0014;
        L0013:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0014:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0012;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0012;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0012;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0012;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0012;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSyncScope, &chunk->thunks, NULL)) goto L0015;
            goto L0016;
        L0015:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0016:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AtomicOrdering, &chunk->thunks, NULL)) goto L0012;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0017;
            goto L0018;
        L0017:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0018:;
        }
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e'
        ) goto L0019;
        ctx->cur += 5;
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c'
        ) goto L0019;
        ctx->cur += 6;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0020;
            goto L0021;
        L0020:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0021:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0019;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0019;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0019;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0019;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0019;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSyncScope, &chunk->thunks, NULL)) goto L0022;
            goto L0023;
        L0022:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0023:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AtomicOrdering, &chunk->thunks, NULL)) goto L0019;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0019;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0019;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0024;
            goto L0025;
        L0024:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0025:;
        }
        goto L0001;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "StoreInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "StoreInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FenceInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FenceInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e'
    ) goto L0000;
    ctx->cur += 5;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSyncScope, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AtomicOrdering, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FenceInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FenceInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CmpXchgInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CmpXchgInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'g'
    ) goto L0000;
    ctx->cur += 7;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptWeak, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSyncScope, &chunk->thunks, NULL)) goto L0005;
        goto L0006;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0006:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AtomicOrdering, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AtomicOrdering, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0007;
        goto L0008;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0008:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CmpXchgInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CmpXchgInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptWeak(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptWeak", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'k'
    ) goto L0000;
    ctx->cur += 4;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptWeak", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptWeak", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AtomicRMWInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AtomicRMWInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 9) < 9 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 't' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'w'
    ) goto L0000;
    ctx->cur += 9;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptVolatile, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BinOp, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptSyncScope, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AtomicOrdering, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0005;
        goto L0006;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0006:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AtomicRMWInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AtomicRMWInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BinOp(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BinOp", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd'
        ) goto L0002;
        ctx->cur += 3;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd'
        ) goto L0003;
        ctx->cur += 3;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'x'
        ) goto L0004;
        ctx->cur += 3;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n'
        ) goto L0005;
        ctx->cur += 3;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd'
        ) goto L0006;
        ctx->cur += 4;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 2) < 2 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r'
        ) goto L0007;
        ctx->cur += 2;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'b'
        ) goto L0008;
        ctx->cur += 3;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'x'
        ) goto L0009;
        ctx->cur += 4;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n'
        ) goto L0010;
        ctx->cur += 4;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g'
        ) goto L0011;
        ctx->cur += 4;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r'
        ) goto L0012;
        ctx->cur += 3;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BinOp", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BinOp", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GetElementPtrInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GetElementPtrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[11] != 't' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'r'
        ) goto L0002;
        ctx->cur += 13;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInBounds, &chunk->thunks, NULL)) goto L0003;
            goto L0004;
        L0003:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0004:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0002;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0002;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0005;
            goto L0006;
        L0005:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0006:;
        }
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[11] != 't' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'r'
        ) goto L0007;
        ctx->cur += 13;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptInBounds, &chunk->thunks, NULL)) goto L0008;
            goto L0009;
        L0008:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0009:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0007;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0007;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0007;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0007;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0007;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CommaSepTypeValueList, &chunk->thunks, NULL)) goto L0007;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0010;
            goto L0011;
        L0010:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0011:;
        }
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GetElementPtrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GetElementPtrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TruncInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TruncInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'c'
    ) goto L0000;
    ctx->cur += 5;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TruncInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TruncInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ZExtInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ZExtInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'z' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ZExtInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ZExtInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SExtInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SExtInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SExtInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SExtInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FPTruncInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FPTruncInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'c'
    ) goto L0000;
    ctx->cur += 7;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FPTruncInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FPTruncInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FPExtInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FPExtInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[4] != 't'
    ) goto L0000;
    ctx->cur += 5;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FPExtInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FPExtInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FPToUIInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FPToUIInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'i'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FPToUIInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FPToUIInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FPToSIInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FPToSIInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 's' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'i'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FPToSIInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FPToSIInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UIToFPInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UIToFPInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UIToFPInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UIToFPInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SIToFPInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SIToFPInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SIToFPInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SIToFPInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_PtrToIntInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "PtrToIntInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[1] != 't' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[7] != 't'
    ) goto L0000;
    ctx->cur += 8;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "PtrToIntInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "PtrToIntInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IntToPtrInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IntToPtrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'r'
    ) goto L0000;
    ctx->cur += 8;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IntToPtrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IntToPtrInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BitCastInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BitCastInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 's' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't'
    ) goto L0000;
    ctx->cur += 7;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BitCastInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BitCastInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AddrSpaceCastInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AddrSpaceCastInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[4] != 's' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[11] != 's' ||
        (ctx->buffer.buf + ctx->cur)[12] != 't'
    ) goto L0000;
    ctx->cur += 13;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AddrSpaceCastInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AddrSpaceCastInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ICmpInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ICmpInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'p'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IPred, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ICmpInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ICmpInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FCmpInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FCmpInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'p'
    ) goto L0000;
    ctx->cur += 4;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlags, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FPred, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FCmpInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FCmpInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_PhiInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "PhiInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 3) < 3 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i'
    ) goto L0000;
    ctx->cur += 3;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IncList, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "PhiInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "PhiInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IncList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IncList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Inc, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IncList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Inc, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IncList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IncList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Inc(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Inc", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '['
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ']'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Inc", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Inc", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SelectInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SelectInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[5] != 't'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SelectInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SelectInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CallInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CallInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptTail, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l'
    ) goto L0000;
    ctx->cur += 4;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlags, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCallingConv, &chunk->thunks, NULL)) goto L0005;
        goto L0006;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0006:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ReturnAttrs, &chunk->thunks, NULL)) goto L0007;
        goto L0008;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0008:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Args, &chunk->thunks, NULL)) goto L0009;
        goto L0010;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0010:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttrs, &chunk->thunks, NULL)) goto L0011;
        goto L0012;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0012:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OperandBundles, &chunk->thunks, NULL)) goto L0013;
        goto L0014;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0014:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0015;
        goto L0016;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0016:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CallInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CallInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptTail(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptTail", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[2] != 's' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l'
        ) goto L0002;
        ctx->cur += 8;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l'
        ) goto L0003;
        ctx->cur += 6;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l'
        ) goto L0004;
        ctx->cur += 4;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptTail", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptTail", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_VAArgInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "VAArgInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != '_' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'g'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "VAArgInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "VAArgInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LandingPadInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LandingPadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 10) < 10 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'd'
    ) goto L0000;
    ctx->cur += 10;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCleanup, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Clauses, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0005;
        goto L0006;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0006:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LandingPadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LandingPadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptCleanup(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptCleanup", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'p'
    ) goto L0000;
    ctx->cur += 7;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptCleanup", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptCleanup", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Clauses(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Clauses", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ClauseList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Clauses", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Clauses", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ClauseList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ClauseList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Clause, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ClauseList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Clause, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ClauseList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ClauseList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Clause(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Clause", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'h'
        ) goto L0002;
        ctx->cur += 5;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r'
        ) goto L0003;
        ctx->cur += 6;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ArrayConst, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Clause", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Clause", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CatchPadInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CatchPadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'd'
    ) goto L0000;
    ctx->cur += 8;
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '['
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExceptionArgs, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ']'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CatchPadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CatchPadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CleanupPadInst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CleanupPadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 10) < 10 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'd'
    ) goto L0000;
    ctx->cur += 10;
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExceptionScope, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '['
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExceptionArgs, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ']'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CleanupPadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CleanupPadInst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Terminator(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Terminator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_RetTerm, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BrTerm, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CondBrTerm, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SwitchTerm, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IndirectBrTerm, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_InvokeTerm, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ResumeTerm, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CatchSwitchTerm, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CatchRetTerm, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CleanupRetTerm, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnreachableTerm, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Terminator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Terminator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_RetTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "RetTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0002;
        ctx->cur += 3;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_VoidType, &chunk->thunks, NULL)) goto L0002;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
            goto L0004;
        L0003:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0004:;
        }
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0005;
        ctx->cur += 3;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ConcreteType, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0005;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0006;
            goto L0007;
        L0006:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0007:;
        }
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "RetTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "RetTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BrTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BrTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BrTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BrTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CondBrTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CondBrTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CondBrTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CondBrTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SwitchTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SwitchTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'h'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '['
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Cases, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ']'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SwitchTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SwitchTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Cases(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Cases", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CaseList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Cases", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Cases", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CaseList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CaseList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Case, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CaseList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Case, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CaseList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CaseList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Case(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Case", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntConst, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Case", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Case", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IndirectBrTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IndirectBrTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 10) < 10 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[7] != 't' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'r'
    ) goto L0000;
    ctx->cur += 10;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '['
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelList, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ']'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IndirectBrTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IndirectBrTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LabelList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LabelList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Label, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Label, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LabelList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LabelList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Label(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Label", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Label", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Label", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_InvokeTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "InvokeTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'k' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'e'
    ) goto L0000;
    ctx->cur += 6;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCallingConv, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ReturnAttrs, &chunk->thunks, NULL)) goto L0003;
        goto L0004;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0004:;
    }
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Args, &chunk->thunks, NULL)) goto L0005;
        goto L0006;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0006:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttrs, &chunk->thunks, NULL)) goto L0007;
        goto L0008;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0008:;
    }
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OperandBundles, &chunk->thunks, NULL)) goto L0009;
        goto L0010;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0010:;
    }
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'd'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0011;
        goto L0012;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0012:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "InvokeTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "InvokeTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ResumeTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ResumeTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 's' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'e'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ResumeTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ResumeTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CatchSwitchTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CatchSwitchTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 11) < 11 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[5] != 's' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[8] != 't' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'h'
    ) goto L0000;
    ctx->cur += 11;
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExceptionScope, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '['
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelList, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ']'
    ) goto L0000;
    ctx->cur++;
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'd'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnwindTarget, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CatchSwitchTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CatchSwitchTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CatchRetTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CatchRetTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 't' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[7] != 't'
    ) goto L0000;
    ctx->cur += 8;
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'm'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 2) < 2 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o'
    ) goto L0000;
    ctx->cur += 2;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CatchRetTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CatchRetTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CleanupRetTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CleanupRetTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 10) < 10 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[9] != 't'
    ) goto L0000;
    ctx->cur += 10;
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'm'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'd'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnwindTarget, &chunk->thunks, NULL)) goto L0000;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CleanupRetTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CleanupRetTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UnreachableTerm(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UnreachableTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 11) < 11 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'h' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e'
    ) goto L0000;
    ctx->cur += 11;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OptCommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UnreachableTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UnreachableTerm", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UnwindTarget(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UnwindTarget", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 2) < 2 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o'
        ) goto L0002;
        ctx->cur += 2;
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r'
        ) goto L0002;
        ctx->cur += 6;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LabelType, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UnwindTarget", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UnwindTarget", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MDTuple(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MDTuple", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '!'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDFields, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MDTuple", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MDTuple", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MDFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MDFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0002;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0002;
        ctx->cur++;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '{'
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '}'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MDFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MDFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MDFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MDFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MDFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MDFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MDField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MDField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l'
        ) goto L0002;
        ctx->cur += 4;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Metadata, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MDField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MDField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Metadata(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Metadata", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDString, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDTuple, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataID, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SpecializedMDNode, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Metadata", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Metadata", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MDString(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MDString", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '!'
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MDString", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MDString", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataAttachment(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataAttachment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataName, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDNode, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataAttachment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataAttachment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MDNode(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MDNode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDTuple, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataID, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SpecializedMDNode, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MDNode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MDNode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataAttachments(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataAttachments", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataAttachmentList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataAttachments", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataAttachments", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_MetadataAttachmentList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "MetadataAttachmentList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataAttachment, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataAttachment, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "MetadataAttachmentList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "MetadataAttachmentList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptCommaSepMetadataAttachmentList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptCommaSepMetadataAttachmentList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptCommaSepMetadataAttachmentList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptCommaSepMetadataAttachmentList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CommaSepMetadataAttachmentList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CommaSepMetadataAttachmentList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataAttachment, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CommaSepMetadataAttachmentList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataAttachment, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CommaSepMetadataAttachmentList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CommaSepMetadataAttachmentList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SpecializedMDNode(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SpecializedMDNode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompileUnit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFile, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIBasicType, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubroutineType, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIDerivedType, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompositeType, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubrange, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIEnumerator, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateTypeParameter, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateValueParameter, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIModule, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DINamespace, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariable, &chunk->thunks, NULL)) goto L0014;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubprogram, &chunk->thunks, NULL)) goto L0015;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlock, &chunk->thunks, NULL)) goto L0016;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockFile, &chunk->thunks, NULL)) goto L0017;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocation, &chunk->thunks, NULL)) goto L0018;
        goto L0001;
    L0018:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocalVariable, &chunk->thunks, NULL)) goto L0019;
        goto L0001;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIExpression, &chunk->thunks, NULL)) goto L0020;
        goto L0001;
    L0020:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableExpression, &chunk->thunks, NULL)) goto L0021;
        goto L0001;
    L0021:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIObjCProperty, &chunk->thunks, NULL)) goto L0022;
        goto L0001;
    L0022:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIImportedEntity, &chunk->thunks, NULL)) goto L0023;
        goto L0001;
    L0023:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacro, &chunk->thunks, NULL)) goto L0024;
        goto L0001;
    L0024:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroFile, &chunk->thunks, NULL)) goto L0025;
        goto L0001;
    L0025:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GenericDINode, &chunk->thunks, NULL)) goto L0026;
        goto L0001;
    L0026:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SpecializedMDNode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SpecializedMDNode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompileUnit(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DICompileUnit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 14) < 14 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'C' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'U' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[13] != 't'
    ) goto L0000;
    ctx->cur += 14;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompileUnitFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DICompileUnit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DICompileUnit", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompileUnitFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DICompileUnitFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompileUnitFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DICompileUnitFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DICompileUnitFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompileUnitFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DICompileUnitFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompileUnitField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompileUnitFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompileUnitField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DICompileUnitFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DICompileUnitFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompileUnitField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DICompileUnitField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != ':'
        ) goto L0002;
        ctx->cur += 9;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DwarfLang, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[8] != ':'
        ) goto L0004;
        ctx->cur += 9;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IsOptimizedField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != ':'
        ) goto L0006;
        ctx->cur += 6;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'V' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[10] != 's' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[14] != ':'
        ) goto L0007;
        ctx->cur += 15;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 19) < 19 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'D' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'F' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[15] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[16] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[17] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[18] != ':'
        ) goto L0008;
        ctx->cur += 19;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'K' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[12] != ':'
        ) goto L0009;
        ctx->cur += 13;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_EmissionKind, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != ':'
        ) goto L0010;
        ctx->cur += 6;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'T' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[12] != 's' ||
            (ctx->buffer.buf + ctx->cur)[13] != ':'
        ) goto L0011;
        ctx->cur += 14;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 's' ||
            (ctx->buffer.buf + ctx->cur)[7] != ':'
        ) goto L0012;
        ctx->cur += 8;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't' ||
            (ctx->buffer.buf + ctx->cur)[6] != 's' ||
            (ctx->buffer.buf + ctx->cur)[7] != ':'
        ) goto L0013;
        ctx->cur += 8;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != ':'
        ) goto L0014;
        ctx->cur += 7;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0014;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'I' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[5] != ':'
        ) goto L0015;
        ctx->cur += 6;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0015;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 19) < 19 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'D' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'I' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[15] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[16] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[17] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[18] != ':'
        ) goto L0016;
        ctx->cur += 19;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolLit, &chunk->thunks, NULL)) goto L0016;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 22) < 22 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'I' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'F' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'P' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[15] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[16] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[17] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[18] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[19] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[20] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[21] != ':'
        ) goto L0017;
        ctx->cur += 22;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolLit, &chunk->thunks, NULL)) goto L0017;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'P' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[10] != 's' ||
            (ctx->buffer.buf + ctx->cur)[11] != ':'
        ) goto L0018;
        ctx->cur += 12;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolLit, &chunk->thunks, NULL)) goto L0018;
        goto L0001;
    L0018:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DICompileUnitField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DICompileUnitField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFile(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIFile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'F' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e'
    ) goto L0000;
    ctx->cur += 7;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFileFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIFile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIFile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFileFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIFileFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFileFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIFileFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIFileFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFileFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIFileFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFileField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFileFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFileField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIFileFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIFileFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFileField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIFileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != ':'
        ) goto L0002;
        ctx->cur += 9;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[9] != ':'
        ) goto L0003;
        ctx->cur += 10;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[12] != ':'
        ) goto L0004;
        ctx->cur += 13;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ChecksumKind, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[8] != ':'
        ) goto L0005;
        ctx->cur += 9;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIFileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIFileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIBasicType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIBasicType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'B' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 's' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'T' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'e'
    ) goto L0000;
    ctx->cur += 12;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIBasicTypeFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIBasicType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIBasicType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIBasicTypeFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIBasicTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIBasicTypeFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIBasicTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIBasicTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIBasicTypeFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIBasicTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIBasicTypeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIBasicTypeFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIBasicTypeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIBasicTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIBasicTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIBasicTypeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIBasicTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TagField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SizeField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AlignField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[8] != ':'
        ) goto L0006;
        ctx->cur += 9;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DwarfAttEncoding, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIBasicTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIBasicTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubroutineType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubroutineType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 17) < 17 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'S' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[9] != 't' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'T' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[15] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[16] != 'e'
    ) goto L0000;
    ctx->cur += 17;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubroutineTypeFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubroutineType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubroutineType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubroutineTypeFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubroutineTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubroutineTypeFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubroutineTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubroutineTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubroutineTypeFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubroutineTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubroutineTypeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubroutineTypeFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubroutineTypeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubroutineTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubroutineTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubroutineTypeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubroutineTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FlagsField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[2] != ':'
        ) goto L0003;
        ctx->cur += 3;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DwarfCC, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != ':'
        ) goto L0004;
        ctx->cur += 6;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubroutineTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubroutineTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIDerivedType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIDerivedType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 14) < 14 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'T' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'e'
    ) goto L0000;
    ctx->cur += 14;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIDerivedTypeFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIDerivedType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIDerivedType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIDerivedTypeFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIDerivedTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIDerivedTypeFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIDerivedTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIDerivedTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIDerivedTypeFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIDerivedTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIDerivedTypeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIDerivedTypeFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIDerivedTypeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIDerivedTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIDerivedTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIDerivedTypeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIDerivedTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TagField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BaseTypeField, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SizeField, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AlignField, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OffsetField, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FlagsField, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'D' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != ':'
        ) goto L0012;
        ctx->cur += 10;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 18) < 18 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'A' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[10] != 's' ||
            (ctx->buffer.buf + ctx->cur)[11] != 's' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'S' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[15] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[16] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[17] != ':'
        ) goto L0013;
        ctx->cur += 18;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIDerivedTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIDerivedTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompositeType(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DICompositeType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 16) < 16 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'C' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[8] != 's' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[10] != 't' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'T' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[15] != 'e'
    ) goto L0000;
    ctx->cur += 16;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompositeTypeFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DICompositeType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DICompositeType", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompositeTypeFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DICompositeTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompositeTypeFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DICompositeTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DICompositeTypeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompositeTypeFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DICompositeTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompositeTypeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompositeTypeFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DICompositeTypeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DICompositeTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DICompositeTypeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DICompositeTypeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DICompositeTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TagField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BaseTypeField, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_SizeField, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AlignField, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OffsetField, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FlagsField, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't' ||
            (ctx->buffer.buf + ctx->cur)[7] != 's' ||
            (ctx->buffer.buf + ctx->cur)[8] != ':'
        ) goto L0012;
        ctx->cur += 9;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'L' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[11] != ':'
        ) goto L0013;
        ctx->cur += 12;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DwarfLang, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'H' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[12] != ':'
        ) goto L0014;
        ctx->cur += 13;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0014;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TemplateParamsField, &chunk->thunks, NULL)) goto L0015;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[10] != ':'
        ) goto L0016;
        ctx->cur += 11;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0016;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 's' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[10] != 't' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[13] != ':'
        ) goto L0017;
        ctx->cur += 14;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0017;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DICompositeTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DICompositeTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubrange(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubrange", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 11) < 11 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'S' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e'
    ) goto L0000;
    ctx->cur += 11;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubrangeFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubrange", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubrange", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubrangeFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubrangeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubrangeFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubrangeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubrangeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubrangeFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubrangeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubrangeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubrangeFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubrangeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubrangeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubrangeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubrangeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubrangeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[4] != 't' ||
        (ctx->buffer.buf + ctx->cur)[5] != ':'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntOrMDField, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 11) < 11 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'w' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'B' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[10] != ':'
    ) goto L0000;
    ctx->cur += 11;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubrangeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubrangeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIEnumerator(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIEnumerator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'E' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[10] != 't' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'r'
    ) goto L0000;
    ctx->cur += 13;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIEnumeratorFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIEnumerator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIEnumerator", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIEnumeratorFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIEnumeratorFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIEnumeratorFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIEnumeratorFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIEnumeratorFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIEnumeratorFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIEnumeratorFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIEnumeratorField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIEnumeratorFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIEnumeratorField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIEnumeratorFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIEnumeratorFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIEnumeratorField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIEnumeratorField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != ':'
        ) goto L0003;
        ctx->cur += 6;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'U' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[10] != ':'
        ) goto L0004;
        ctx->cur += 11;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolLit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIEnumeratorField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIEnumeratorField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateTypeParameter(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DITemplateTypeParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 24) < 24 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'T' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[9] != 't' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'T' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[15] != 'P' ||
        (ctx->buffer.buf + ctx->cur)[16] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[17] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[18] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[19] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[20] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[21] != 't' ||
        (ctx->buffer.buf + ctx->cur)[22] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[23] != 'r'
    ) goto L0000;
    ctx->cur += 24;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateTypeParameterFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DITemplateTypeParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DITemplateTypeParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateTypeParameterFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DITemplateTypeParameterFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateTypeParameterFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DITemplateTypeParameterFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DITemplateTypeParameterFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateTypeParameterFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DITemplateTypeParameterFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateTypeParameterField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateTypeParameterFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateTypeParameterField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DITemplateTypeParameterFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DITemplateTypeParameterFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateTypeParameterField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DITemplateTypeParameterField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DITemplateTypeParameterField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DITemplateTypeParameterField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateValueParameter(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DITemplateValueParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 25) < 25 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'T' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[9] != 't' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'V' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[15] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[16] != 'P' ||
        (ctx->buffer.buf + ctx->cur)[17] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[18] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[19] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[20] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[21] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[22] != 't' ||
        (ctx->buffer.buf + ctx->cur)[23] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[24] != 'r'
    ) goto L0000;
    ctx->cur += 25;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateValueParameterFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DITemplateValueParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DITemplateValueParameter", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateValueParameterFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DITemplateValueParameterFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateValueParameterFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DITemplateValueParameterFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DITemplateValueParameterFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateValueParameterFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DITemplateValueParameterFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateValueParameterField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateValueParameterFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DITemplateValueParameterField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DITemplateValueParameterFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DITemplateValueParameterFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DITemplateValueParameterField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DITemplateValueParameterField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TagField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != ':'
        ) goto L0005;
        ctx->cur += 6;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DITemplateValueParameterField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DITemplateValueParameterField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIModule(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIModule", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 9) < 9 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'M' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e'
    ) goto L0000;
    ctx->cur += 9;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIModuleFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIModule", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIModule", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIModuleFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIModuleFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIModuleFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIModuleFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIModuleFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIModuleFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIModuleFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIModuleField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIModuleFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIModuleField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIModuleFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIModuleFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIModuleField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIModuleField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'M' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[11] != 's' ||
            (ctx->buffer.buf + ctx->cur)[12] != ':'
        ) goto L0004;
        ctx->cur += 13;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'P' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[11] != ':'
        ) goto L0005;
        ctx->cur += 12;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't' ||
            (ctx->buffer.buf + ctx->cur)[8] != ':'
        ) goto L0006;
        ctx->cur += 9;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIModuleField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIModuleField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DINamespace(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DINamespace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'N' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[7] != 's' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'e'
    ) goto L0000;
    ctx->cur += 12;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DINamespaceFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DINamespace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DINamespace", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DINamespaceFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DINamespaceFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DINamespaceFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DINamespaceFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DINamespaceFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DINamespaceFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DINamespaceFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DINamespaceField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DINamespaceFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DINamespaceField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DINamespaceFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DINamespaceFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DINamespaceField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DINamespaceField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'S' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[12] != 's' ||
            (ctx->buffer.buf + ctx->cur)[13] != ':'
        ) goto L0004;
        ctx->cur += 14;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolLit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DINamespaceField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DINamespaceField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariable(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIGlobalVariable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 17) < 17 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'G' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'V' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[15] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[16] != 'e'
    ) goto L0000;
    ctx->cur += 17;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIGlobalVariable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIGlobalVariable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIGlobalVariableFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIGlobalVariableFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIGlobalVariableFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIGlobalVariableFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIGlobalVariableFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIGlobalVariableFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIGlobalVariableField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LinkageNameField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeField, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IsLocalField, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IsDefinitionField, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DeclarationField, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AlignField, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIGlobalVariableField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIGlobalVariableField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubprogram(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubprogram", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'S' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'm'
    ) goto L0000;
    ctx->cur += 13;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubprogramFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubprogram", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubprogram", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubprogramFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubprogramFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubprogramFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubprogramFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubprogramFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubprogramFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubprogramFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubprogramField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubprogramFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DISubprogramField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubprogramFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubprogramFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DISubprogramField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DISubprogramField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LinkageNameField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeField, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IsLocalField, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IsDefinitionField, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'L' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != ':'
        ) goto L0010;
        ctx->cur += 10;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0010;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'T' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[14] != ':'
        ) goto L0011;
        ctx->cur += 15;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0011;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 't' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[10] != ':'
        ) goto L0012;
        ctx->cur += 11;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DwarfVirtuality, &chunk->thunks, NULL)) goto L0012;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'I' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[12] != ':'
        ) goto L0013;
        ctx->cur += 13;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0013;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'A' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'j' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[13] != 't' ||
            (ctx->buffer.buf + ctx->cur)[14] != ':'
        ) goto L0014;
        ctx->cur += 15;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0014;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FlagsField, &chunk->thunks, NULL)) goto L0015;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IsOptimizedField, &chunk->thunks, NULL)) goto L0016;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != ':'
        ) goto L0017;
        ctx->cur += 5;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0017;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TemplateParamsField, &chunk->thunks, NULL)) goto L0018;
        goto L0001;
    L0018:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DeclarationField, &chunk->thunks, NULL)) goto L0019;
        goto L0001;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's' ||
            (ctx->buffer.buf + ctx->cur)[9] != ':'
        ) goto L0020;
        ctx->cur += 10;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0020;
        goto L0001;
    L0020:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'T' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[10] != 's' ||
            (ctx->buffer.buf + ctx->cur)[11] != ':'
        ) goto L0021;
        ctx->cur += 12;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0021;
        goto L0001;
    L0021:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DISubprogramField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DISubprogramField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlock(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILexicalBlock", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 15) < 15 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'L' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'B' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'k'
    ) goto L0000;
    ctx->cur += 15;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILexicalBlock", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILexicalBlock", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILexicalBlockFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILexicalBlockFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILexicalBlockFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILexicalBlockFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILexicalBlockFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILexicalBlockFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILexicalBlockField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ColumnField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILexicalBlockField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILexicalBlockField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFile(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILexicalBlockFile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 19) < 19 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'L' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'B' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'k' ||
        (ctx->buffer.buf + ctx->cur)[15] != 'F' ||
        (ctx->buffer.buf + ctx->cur)[16] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[17] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[18] != 'e'
    ) goto L0000;
    ctx->cur += 19;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockFileFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILexicalBlockFile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILexicalBlockFile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFileFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILexicalBlockFileFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockFileFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILexicalBlockFileFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILexicalBlockFileFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFileFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILexicalBlockFileFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockFileField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockFileFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILexicalBlockFileField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILexicalBlockFileFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILexicalBlockFileFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILexicalBlockFileField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILexicalBlockFileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 's' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[10] != 't' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[13] != ':'
        ) goto L0004;
        ctx->cur += 14;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILexicalBlockFileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILexicalBlockFileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocation(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILocation", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 11) < 11 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'L' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[7] != 't' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'n'
    ) goto L0000;
    ctx->cur += 11;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocationFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILocation", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILocation", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocationFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILocationFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocationFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILocationFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILocationFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocationFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILocationFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocationField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocationFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocationField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILocationFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILocationFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocationField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILocationField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ColumnField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'A' ||
            (ctx->buffer.buf + ctx->cur)[8] != 't' ||
            (ctx->buffer.buf + ctx->cur)[9] != ':'
        ) goto L0005;
        ctx->cur += 10;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILocationField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILocationField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocalVariable(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILocalVariable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 16) < 16 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'L' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'V' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[15] != 'e'
    ) goto L0000;
    ctx->cur += 16;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocalVariableFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILocalVariable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILocalVariable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocalVariableFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILocalVariableFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocalVariableFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILocalVariableFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILocalVariableFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocalVariableFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILocalVariableFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocalVariableField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocalVariableFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DILocalVariableField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILocalVariableFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILocalVariableFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DILocalVariableField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DILocalVariableField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[3] != ':'
        ) goto L0003;
        ctx->cur += 4;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeField, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FlagsField, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AlignField, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DILocalVariableField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DILocalVariableField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIExpression(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'E' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[8] != 's' ||
        (ctx->buffer.buf + ctx->cur)[9] != 's' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'n'
    ) goto L0000;
    ctx->cur += 13;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIExpressionFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIExpressionFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIExpressionFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIExpressionFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIExpressionFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIExpressionFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIExpressionFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIExpressionFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIExpressionField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIExpressionFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIExpressionField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIExpressionFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIExpressionFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIExpressionField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIExpressionField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DwarfOp, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIExpressionField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIExpressionField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableExpression(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIGlobalVariableExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 27) < 27 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'G' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'V' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[15] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[16] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[17] != 'E' ||
        (ctx->buffer.buf + ctx->cur)[18] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[19] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[20] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[21] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[22] != 's' ||
        (ctx->buffer.buf + ctx->cur)[23] != 's' ||
        (ctx->buffer.buf + ctx->cur)[24] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[25] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[26] != 'n'
    ) goto L0000;
    ctx->cur += 27;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableExpressionFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIGlobalVariableExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIGlobalVariableExpression", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableExpressionFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIGlobalVariableExpressionFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableExpressionFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIGlobalVariableExpressionFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIGlobalVariableExpressionFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableExpressionFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIGlobalVariableExpressionFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableExpressionField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableExpressionFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIGlobalVariableExpressionField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIGlobalVariableExpressionFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIGlobalVariableExpressionFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIGlobalVariableExpressionField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIGlobalVariableExpressionField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != ':'
        ) goto L0002;
        ctx->cur += 4;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != ':'
        ) goto L0003;
        ctx->cur += 5;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIGlobalVariableExpressionField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIGlobalVariableExpressionField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIObjCProperty(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIObjCProperty", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 15) < 15 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'O' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'j' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'C' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'P' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[13] != 't' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'y'
    ) goto L0000;
    ctx->cur += 15;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIObjCPropertyFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIObjCProperty", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIObjCProperty", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIObjCPropertyFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIObjCPropertyFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIObjCPropertyFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIObjCPropertyFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIObjCPropertyFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIObjCPropertyFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIObjCPropertyFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIObjCPropertyField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIObjCPropertyFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIObjCPropertyField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIObjCPropertyFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIObjCPropertyFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIObjCPropertyField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIObjCPropertyField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[6] != ':'
        ) goto L0005;
        ctx->cur += 7;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[6] != ':'
        ) goto L0006;
        ctx->cur += 7;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != 's' ||
            (ctx->buffer.buf + ctx->cur)[10] != ':'
        ) goto L0007;
        ctx->cur += 11;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeField, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIObjCPropertyField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIObjCPropertyField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIImportedEntity(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIImportedEntity", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 17) < 17 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[8] != 't' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'E' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[13] != 't' ||
        (ctx->buffer.buf + ctx->cur)[14] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[15] != 't' ||
        (ctx->buffer.buf + ctx->cur)[16] != 'y'
    ) goto L0000;
    ctx->cur += 17;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIImportedEntityFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIImportedEntity", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIImportedEntity", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIImportedEntityFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIImportedEntityFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIImportedEntityFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIImportedEntityFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIImportedEntityFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIImportedEntityFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIImportedEntityFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIImportedEntityField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIImportedEntityFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIImportedEntityField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIImportedEntityFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIImportedEntityFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIImportedEntityField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIImportedEntityField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TagField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ScopeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[6] != ':'
        ) goto L0004;
        ctx->cur += 7;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIImportedEntityField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIImportedEntityField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacro(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIMacro", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'M' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'o'
    ) goto L0000;
    ctx->cur += 8;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIMacro", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIMacro", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIMacroFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIMacroFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIMacroFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIMacroFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIMacroFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIMacroFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIMacroField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeMacinfoField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NameField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != ':'
        ) goto L0005;
        ctx->cur += 6;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIMacroField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIMacroField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFile(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIMacroFile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'M' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'F' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'e'
    ) goto L0000;
    ctx->cur += 12;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroFileFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIMacroFile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIMacroFile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFileFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIMacroFileFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroFileFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIMacroFileFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIMacroFileFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFileFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIMacroFileFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroFileField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroFileFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIMacroFileField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIMacroFileFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIMacroFileFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIMacroFileField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIMacroFileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeMacinfoField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LineField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FileField, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != ':'
        ) goto L0005;
        ctx->cur += 6;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIMacroFileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIMacroFileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GenericDINode(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GenericDINode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 14) < 14 ||
        (ctx->buffer.buf + ctx->cur)[0] != '!' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'G' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'I' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'N' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[13] != 'e'
    ) goto L0000;
    ctx->cur += 14;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GenericDINodeFields, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GenericDINode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GenericDINode", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GenericDINodeFields(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GenericDINodeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GenericDINodeFieldList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GenericDINodeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GenericDINodeFields", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GenericDINodeFieldList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GenericDINodeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GenericDINodeField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GenericDINodeFieldList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_GenericDINodeField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GenericDINodeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GenericDINodeFieldList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_GenericDINodeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "GenericDINodeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TagField, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[6] != ':'
        ) goto L0003;
        ctx->cur += 7;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[7] != 's' ||
            (ctx->buffer.buf + ctx->cur)[8] != ':'
        ) goto L0004;
        ctx->cur += 9;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDFields, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "GenericDINodeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "GenericDINodeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FileField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != ':'
    ) goto L0000;
    ctx->cur += 5;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FileField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IsOptimizedField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IsOptimizedField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'O' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[4] != 't' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'z' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[11] != ':'
    ) goto L0000;
    ctx->cur += 12;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IsOptimizedField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IsOptimizedField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TagField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TagField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 4) < 4 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[3] != ':'
    ) goto L0000;
    ctx->cur += 4;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DwarfTag, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TagField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TagField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_NameField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "NameField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != ':'
    ) goto L0000;
    ctx->cur += 5;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "NameField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "NameField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_SizeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "SizeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'z' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != ':'
    ) goto L0000;
    ctx->cur += 5;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "SizeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "SizeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AlignField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AlignField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != ':'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AlignField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AlignField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FlagsField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FlagsField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[4] != 's' ||
        (ctx->buffer.buf + ctx->cur)[5] != ':'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFlagList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FlagsField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FlagsField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LineField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LineField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != ':'
    ) goto L0000;
    ctx->cur += 5;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LineField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LineField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ScopeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ScopeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 6) < 6 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[5] != ':'
    ) goto L0000;
    ctx->cur += 6;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ScopeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ScopeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_BaseTypeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "BaseTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 9) < 9 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[2] != 's' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'T' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[8] != ':'
    ) goto L0000;
    ctx->cur += 9;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "BaseTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "BaseTypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OffsetField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OffsetField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[3] != 's' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[5] != 't' ||
        (ctx->buffer.buf + ctx->cur)[6] != ':'
    ) goto L0000;
    ctx->cur += 7;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OffsetField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OffsetField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TemplateParamsField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TemplateParamsField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 15) < 15 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'P' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[12] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[13] != 's' ||
        (ctx->buffer.buf + ctx->cur)[14] != ':'
    ) goto L0000;
    ctx->cur += 15;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TemplateParamsField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TemplateParamsField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IntOrMDField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IntOrMDField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IntOrMDField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IntOrMDField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != ':'
    ) goto L0000;
    ctx->cur += 5;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_LinkageNameField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "LinkageNameField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'k' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'N' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[11] != ':'
    ) goto L0000;
    ctx->cur += 12;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "LinkageNameField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "LinkageNameField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IsLocalField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IsLocalField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'L' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[7] != ':'
    ) goto L0000;
    ctx->cur += 8;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IsLocalField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IsLocalField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IsDefinitionField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IsDefinitionField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 13) < 13 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 's' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'D' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[8] != 't' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[11] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[12] != ':'
    ) goto L0000;
    ctx->cur += 13;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_BoolLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IsDefinitionField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IsDefinitionField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DeclarationField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DeclarationField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 12) < 12 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[7] != 't' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[10] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[11] != ':'
    ) goto L0000;
    ctx->cur += 12;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MDField, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DeclarationField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DeclarationField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ColumnField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ColumnField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'm' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[6] != ':'
    ) goto L0000;
    ctx->cur += 7;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ColumnField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ColumnField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeMacinfoField(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeMacinfoField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 't' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[4] != ':'
    ) goto L0000;
    ctx->cur += 5;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DwarfMacinfo, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeMacinfoField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeMacinfoField", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ChecksumKind(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ChecksumKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_checksum_kind, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ChecksumKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ChecksumKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFlagList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIFlagList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFlag, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFlagList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '|'
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DIFlag, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIFlagList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIFlagList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DIFlag(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DIFlag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_di_flag, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DIFlag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DIFlag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfAttEncoding(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DwarfAttEncoding", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_dwarf_att_encoding, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DwarfAttEncoding", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DwarfAttEncoding", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfCC(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DwarfCC", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_dwarf_cc, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DwarfCC", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DwarfCC", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfLang(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DwarfLang", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_dwarf_lang, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DwarfLang", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DwarfLang", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfMacinfo(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DwarfMacinfo", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_dwarf_macinfo, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DwarfMacinfo", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DwarfMacinfo", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfOp(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DwarfOp", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_dwarf_op, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DwarfOp", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DwarfOp", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfTag(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DwarfTag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_dwarf_tag, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DwarfTag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DwarfTag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DwarfVirtuality(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DwarfVirtuality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_dwarf_virtuality, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DwarfVirtuality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DwarfVirtuality", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_EmissionKind(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "EmissionKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IntLit, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'F' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'D' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'g'
        ) goto L0003;
        ctx->cur += 9;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'L' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'T' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != 's' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'O' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'y'
        ) goto L0004;
        ctx->cur += 14;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'N' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'D' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'g'
        ) goto L0005;
        ctx->cur += 7;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "EmissionKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "EmissionKind", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeValues(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeValues", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeValueList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeValues", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeValues", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeValueList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeValueList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeValue, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeValueList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeValue, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeValueList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeValueList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CommaSepTypeValueList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CommaSepTypeValueList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeValue, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CommaSepTypeValueList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeValue, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CommaSepTypeValueList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CommaSepTypeValueList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeValue(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeValue", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeValue", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeValue", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeConsts(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeConsts", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeConstList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeConsts", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeConsts", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeConstList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeConstList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeConst, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeConstList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeConst, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeConstList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeConstList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TypeConst(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TypeConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0000;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Constant, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TypeConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TypeConst", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Alignment(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Alignment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n'
    ) goto L0000;
    ctx->cur += 5;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Alignment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Alignment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AllocSize(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AllocSize", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e'
        ) goto L0002;
        ctx->cur += 9;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '('
        ) goto L0002;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0002;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ')'
        ) goto L0002;
        ctx->cur++;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e'
        ) goto L0003;
        ctx->cur += 9;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '('
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ')'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AllocSize", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AllocSize", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Args(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Args", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != '.' ||
            (ctx->buffer.buf + ctx->cur)[1] != '.' ||
            (ctx->buffer.buf + ctx->cur)[2] != '.'
        ) goto L0002;
        ctx->cur += 3;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ArgList, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ArgList, &chunk->thunks, NULL)) goto L0004;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != '.' ||
            (ctx->buffer.buf + ctx->cur)[1] != '.' ||
            (ctx->buffer.buf + ctx->cur)[2] != '.'
        ) goto L0004;
        ctx->cur += 3;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Args", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Args", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ArgList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ArgList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Arg, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ArgList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Arg, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ArgList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ArgList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Arg(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Arg", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ConcreteType, &chunk->thunks, NULL)) goto L0002;
        {
            const size_t p = ctx->cur;
            const size_t n = chunk->thunks.len;
            if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamAttrs, &chunk->thunks, NULL)) goto L0003;
            goto L0004;
        L0003:;
            ctx->cur = p;
            pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        L0004:;
        }
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataType, &chunk->thunks, NULL)) goto L0005;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Metadata, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Arg", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Arg", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_AtomicOrdering(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "AtomicOrdering", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'q' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'l'
        ) goto L0002;
        ctx->cur += 7;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'q' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e'
        ) goto L0003;
        ctx->cur += 7;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c'
        ) goto L0004;
        ctx->cur += 9;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e'
        ) goto L0005;
        ctx->cur += 7;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'q' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't'
        ) goto L0006;
        ctx->cur += 7;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'd'
        ) goto L0007;
        ctx->cur += 9;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "AtomicOrdering", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "AtomicOrdering", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptCallingConv(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptCallingConv", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_CallingConv, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptCallingConv", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptCallingConv", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_CallingConv(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "CallingConv", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's'
        ) goto L0002;
        ctx->cur += 9;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's'
        ) goto L0003;
        ctx->cur += 9;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's'
        ) goto L0004;
        ctx->cur += 9;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's'
        ) goto L0005;
        ctx->cur += 9;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'l'
        ) goto L0006;
        ctx->cur += 13;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's'
        ) goto L0007;
        ctx->cur += 9;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's'
        ) goto L0008;
        ctx->cur += 9;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's'
        ) goto L0009;
        ctx->cur += 9;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c'
        ) goto L0010;
        ctx->cur += 8;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's' ||
            (ctx->buffer.buf + ctx->cur)[9] != '_' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'c'
        ) goto L0011;
        ctx->cur += 15;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'c'
        ) goto L0012;
        ctx->cur += 11;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[7] != 's' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'c'
        ) goto L0013;
        ctx->cur += 10;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'c'
        ) goto L0014;
        ctx->cur += 10;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'c'
        ) goto L0015;
        ctx->cur += 12;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c'
        ) goto L0016;
        ctx->cur += 3;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c'
        ) goto L0017;
        ctx->cur += 6;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 's' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't' ||
            (ctx->buffer.buf + ctx->cur)[8] != '_' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[11] != 's' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'c'
        ) goto L0018;
        ctx->cur += 14;
        goto L0001;
    L0018:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 's' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c'
        ) goto L0019;
        ctx->cur += 6;
        goto L0001;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c'
        ) goto L0020;
        ctx->cur += 5;
        goto L0001;
    L0020:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != '_' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c'
        ) goto L0021;
        ctx->cur += 8;
        goto L0001;
    L0021:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c'
        ) goto L0022;
        ctx->cur += 6;
        goto L0001;
    L0022:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != '_' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[9] != '_' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'c'
        ) goto L0023;
        ctx->cur += 14;
        goto L0001;
    L0023:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != '4' ||
            (ctx->buffer.buf + ctx->cur)[4] != '3' ||
            (ctx->buffer.buf + ctx->cur)[5] != '0' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'c'
        ) goto L0024;
        ctx->cur += 13;
        goto L0001;
    L0024:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != '_' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'c'
        ) goto L0025;
        ctx->cur += 14;
        goto L0001;
    L0025:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != '_' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[11] != 's' ||
            (ctx->buffer.buf + ctx->cur)[12] != 't' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'c'
        ) goto L0026;
        ctx->cur += 15;
        goto L0001;
    L0026:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'e'
        ) goto L0027;
        ctx->cur += 10;
        goto L0001;
    L0027:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'l'
        ) goto L0028;
        ctx->cur += 10;
        goto L0001;
    L0028:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != '_' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c'
        ) goto L0029;
        ctx->cur += 9;
        goto L0001;
    L0029:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != '_' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l'
        ) goto L0030;
        ctx->cur += 11;
        goto L0001;
    L0030:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c'
        ) goto L0031;
        ctx->cur += 7;
        goto L0001;
    L0031:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'j' ||
            (ctx->buffer.buf + ctx->cur)[8] != 's' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'c'
        ) goto L0032;
        ctx->cur += 11;
        goto L0001;
    L0032:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != '6' ||
            (ctx->buffer.buf + ctx->cur)[4] != '4' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c'
        ) goto L0033;
        ctx->cur += 7;
        goto L0001;
    L0033:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != '8' ||
            (ctx->buffer.buf + ctx->cur)[2] != '6' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != '6' ||
            (ctx->buffer.buf + ctx->cur)[5] != '4' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 's' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[9] != 's' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'c'
        ) goto L0034;
        ctx->cur += 13;
        goto L0001;
    L0034:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != '8' ||
            (ctx->buffer.buf + ctx->cur)[2] != '6' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 's' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'c'
        ) goto L0035;
        ctx->cur += 14;
        goto L0001;
    L0035:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != '8' ||
            (ctx->buffer.buf + ctx->cur)[2] != '6' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'c'
        ) goto L0036;
        ctx->cur += 10;
        goto L0001;
    L0036:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != '8' ||
            (ctx->buffer.buf + ctx->cur)[2] != '6' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'c'
        ) goto L0037;
        ctx->cur += 13;
        goto L0001;
    L0037:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != '8' ||
            (ctx->buffer.buf + ctx->cur)[2] != '6' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'c'
        ) goto L0038;
        ctx->cur += 13;
        goto L0001;
    L0038:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 14) < 14 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != '8' ||
            (ctx->buffer.buf + ctx->cur)[2] != '6' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 's' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'c'
        ) goto L0039;
        ctx->cur += 14;
        goto L0001;
    L0039:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 16) < 16 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[1] != '8' ||
            (ctx->buffer.buf + ctx->cur)[2] != '6' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[15] != 'c'
        ) goto L0040;
        ctx->cur += 16;
        goto L0001;
    L0040:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 2) < 2 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'c'
        ) goto L0041;
        ctx->cur += 2;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0041;
        goto L0001;
    L0041:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "CallingConv", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "CallingConv", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptComdat(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptComdat", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Comdat, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptComdat", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptComdat", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Comdat(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Comdat", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't'
        ) goto L0002;
        ctx->cur += 6;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't'
        ) goto L0003;
        ctx->cur += 6;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '('
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ComdatName, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ')'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Comdat", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Comdat", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Dereferenceable(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Dereferenceable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'e'
        ) goto L0002;
        ctx->cur += 15;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '('
        ) goto L0002;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0002;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ')'
        ) goto L0002;
        ctx->cur++;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 23) < 23 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[15] != '_' ||
            (ctx->buffer.buf + ctx->cur)[16] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[17] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[18] != '_' ||
            (ctx->buffer.buf + ctx->cur)[19] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[20] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[21] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[22] != 'l'
        ) goto L0003;
        ctx->cur += 23;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '('
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ')'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Dereferenceable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Dereferenceable", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptDLLStorageClass(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptDLLStorageClass", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_DLLStorageClass, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptDLLStorageClass", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptDLLStorageClass", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_DLLStorageClass(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "DLLStorageClass", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[8] != 't'
        ) goto L0002;
        ctx->cur += 9;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[8] != 't'
        ) goto L0003;
        ctx->cur += 9;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "DLLStorageClass", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "DLLStorageClass", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptExact(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptExact", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 5) < 5 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[4] != 't'
    ) goto L0000;
    ctx->cur += 5;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptExact", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptExact", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ExceptionArgs(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ExceptionArgs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExceptionArgList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ExceptionArgs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ExceptionArgs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ExceptionArgList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ExceptionArgList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExceptionArg, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExceptionArgList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExceptionArg, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ExceptionArgList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ExceptionArgList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ExceptionArg(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ExceptionArg", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ConcreteType, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Value, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_MetadataType, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Metadata, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ExceptionArg", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ExceptionArg", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ExceptionScope(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ExceptionScope", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_NoneConst, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ExceptionScope", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ExceptionScope", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FastMathFlags(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FastMathFlags", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlagList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FastMathFlags", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FastMathFlags", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FastMathFlagList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FastMathFlagList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlag, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlagList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FastMathFlag, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FastMathFlagList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FastMathFlagList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FastMathFlag(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FastMathFlag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n'
        ) goto L0002;
        ctx->cur += 3;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'p'
        ) goto L0003;
        ctx->cur += 4;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't'
        ) goto L0004;
        ctx->cur += 8;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 's' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't'
        ) goto L0005;
        ctx->cur += 4;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'f'
        ) goto L0006;
        ctx->cur += 4;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n'
        ) goto L0007;
        ctx->cur += 4;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'z'
        ) goto L0008;
        ctx->cur += 3;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c'
        ) goto L0009;
        ctx->cur += 7;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FastMathFlag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FastMathFlag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FPred(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FPred", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e'
        ) goto L0002;
        ctx->cur += 5;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'q'
        ) goto L0003;
        ctx->cur += 3;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0004;
        ctx->cur += 3;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0005;
        ctx->cur += 3;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0006;
        ctx->cur += 3;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0007;
        ctx->cur += 3;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0008;
        ctx->cur += 3;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd'
        ) goto L0009;
        ctx->cur += 3;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e'
        ) goto L0010;
        ctx->cur += 4;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'q'
        ) goto L0011;
        ctx->cur += 3;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0012;
        ctx->cur += 3;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0013;
        ctx->cur += 3;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0014;
        ctx->cur += 3;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0015;
        ctx->cur += 3;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0016;
        ctx->cur += 3;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o'
        ) goto L0017;
        ctx->cur += 3;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FPred", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FPred", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FuncAttrs(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FuncAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttrList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FuncAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FuncAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FuncAttrList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FuncAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttr, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttrList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_FuncAttr, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FuncAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FuncAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_FuncAttr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "FuncAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AttrGroupID, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'n'
        ) goto L0003;
        ctx->cur += 5;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'k'
        ) goto L0004;
        ctx->cur += 10;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0004;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0005;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_AllocSize, &chunk->thunks, NULL)) goto L0006;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StackAlignment, &chunk->thunks, NULL)) goto L0007;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0008;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0009;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '='
        ) goto L0009;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0009;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'e'
        ) goto L0010;
        ctx->cur += 12;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'y'
        ) goto L0011;
        ctx->cur += 10;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n'
        ) goto L0012;
        ctx->cur += 7;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd'
        ) goto L0013;
        ctx->cur += 4;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't'
        ) goto L0014;
        ctx->cur += 10;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 29) < 29 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 's' ||
            (ctx->buffer.buf + ctx->cur)[7] != 's' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[15] != '_' ||
            (ctx->buffer.buf + ctx->cur)[16] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[17] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[18] != '_' ||
            (ctx->buffer.buf + ctx->cur)[19] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[20] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[21] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[22] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[23] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[24] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[25] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[26] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[27] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[28] != 'y'
        ) goto L0015;
        ctx->cur += 29;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 19) < 19 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 's' ||
            (ctx->buffer.buf + ctx->cur)[7] != 's' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[15] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[16] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[17] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[18] != 'y'
        ) goto L0016;
        ctx->cur += 19;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't'
        ) goto L0017;
        ctx->cur += 10;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'j' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e'
        ) goto L0018;
        ctx->cur += 9;
        goto L0001;
    L0018:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e'
        ) goto L0019;
        ctx->cur += 7;
        goto L0001;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'd'
        ) goto L0020;
        ctx->cur += 5;
        goto L0001;
    L0020:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n'
        ) goto L0021;
        ctx->cur += 9;
        goto L0001;
    L0021:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'e'
        ) goto L0022;
        ctx->cur += 11;
        goto L0001;
    L0022:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[14] != 't'
        ) goto L0023;
        ctx->cur += 15;
        goto L0001;
    L0023:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e'
        ) goto L0024;
        ctx->cur += 8;
        goto L0001;
    L0024:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'd'
        ) goto L0025;
        ctx->cur += 11;
        goto L0001;
    L0025:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[7] != 's' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e'
        ) goto L0026;
        ctx->cur += 9;
        goto L0001;
    L0026:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e'
        ) goto L0027;
        ctx->cur += 9;
        goto L0001;
    L0027:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n'
        ) goto L0028;
        ctx->cur += 8;
        goto L0001;
    L0028:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'd'
        ) goto L0029;
        ctx->cur += 8;
        goto L0001;
    L0029:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e'
        ) goto L0030;
        ctx->cur += 7;
        goto L0001;
    L0030:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e'
        ) goto L0031;
        ctx->cur += 7;
        goto L0001;
    L0031:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e'
        ) goto L0032;
        ctx->cur += 8;
        goto L0001;
    L0032:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'y'
        ) goto L0033;
        ctx->cur += 8;
        goto L0001;
    L0033:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 13) < 13 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 's' ||
            (ctx->buffer.buf + ctx->cur)[7] != '_' ||
            (ctx->buffer.buf + ctx->cur)[8] != 't' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'e'
        ) goto L0034;
        ctx->cur += 13;
        goto L0001;
    L0034:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 's' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'k'
        ) goto L0035;
        ctx->cur += 9;
        goto L0001;
    L0035:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 16) < 16 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != '_' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[14] != 's' ||
            (ctx->buffer.buf + ctx->cur)[15] != 's'
        ) goto L0036;
        ctx->cur += 16;
        goto L0001;
    L0036:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 18) < 18 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != '_' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[15] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[16] != 's' ||
            (ctx->buffer.buf + ctx->cur)[17] != 's'
        ) goto L0037;
        ctx->cur += 18;
        goto L0001;
    L0037:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != '_' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'y'
        ) goto L0038;
        ctx->cur += 15;
        goto L0001;
    L0038:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != '_' ||
            (ctx->buffer.buf + ctx->cur)[9] != 't' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'd'
        ) goto L0039;
        ctx->cur += 15;
        goto L0001;
    L0039:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[7] != 't' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'e'
        ) goto L0040;
        ctx->cur += 12;
        goto L0001;
    L0040:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p'
        ) goto L0041;
        ctx->cur += 3;
        goto L0001;
    L0041:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'q'
        ) goto L0042;
        ctx->cur += 6;
        goto L0001;
    L0042:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != 's' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'g'
        ) goto L0043;
        ctx->cur += 9;
        goto L0001;
    L0043:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 't' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'p'
        ) goto L0044;
        ctx->cur += 8;
        goto L0001;
    L0044:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e'
        ) goto L0045;
        ctx->cur += 7;
        goto L0001;
    L0045:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'y'
        ) goto L0046;
        ctx->cur += 9;
        goto L0001;
    L0046:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "FuncAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "FuncAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptInBounds(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptInBounds", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'b' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'd' ||
        (ctx->buffer.buf + ctx->cur)[7] != 's'
    ) goto L0000;
    ctx->cur += 8;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptInBounds", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptInBounds", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Indices(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Indices", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ','
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IndexList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Indices", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Indices", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IndexList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IndexList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Index, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_IndexList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Index, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IndexList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IndexList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Index(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Index", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Index", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Index", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_IPred(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "IPred", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 2) < 2 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'q'
        ) goto L0002;
        ctx->cur += 2;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 2) < 2 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e'
        ) goto L0003;
        ctx->cur += 2;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0004;
        ctx->cur += 3;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0005;
        ctx->cur += 3;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0006;
        ctx->cur += 3;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0007;
        ctx->cur += 3;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0008;
        ctx->cur += 3;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0009;
        ctx->cur += 3;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e'
        ) goto L0010;
        ctx->cur += 3;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't'
        ) goto L0011;
        ctx->cur += 3;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "IPred", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "IPred", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptLinkage(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptLinkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Linkage, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptLinkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptLinkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Linkage(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Linkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'g'
        ) goto L0002;
        ctx->cur += 9;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 20) < 20 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != '_' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[12] != 't' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[15] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[16] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[17] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[18] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[19] != 'y'
        ) goto L0003;
        ctx->cur += 20;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n'
        ) goto L0004;
        ctx->cur += 6;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l'
        ) goto L0005;
        ctx->cur += 8;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e'
        ) goto L0006;
        ctx->cur += 8;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != '_' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'r'
        ) goto L0007;
        ctx->cur += 12;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e'
        ) goto L0008;
        ctx->cur += 7;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'k'
        ) goto L0009;
        ctx->cur += 4;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'k' ||
            (ctx->buffer.buf + ctx->cur)[4] != '_' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r'
        ) goto L0010;
        ctx->cur += 8;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Linkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Linkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptExternLinkage(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptExternLinkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ExternLinkage, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptExternLinkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptExternLinkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ExternLinkage(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ExternLinkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'k'
        ) goto L0002;
        ctx->cur += 11;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l'
        ) goto L0003;
        ctx->cur += 8;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ExternLinkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ExternLinkage", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OperandBundles(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OperandBundles", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '['
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OperandBundleList, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ']'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OperandBundles", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OperandBundles", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OperandBundleList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OperandBundleList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OperandBundle, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OperandBundleList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OperandBundle, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OperandBundleList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OperandBundleList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OperandBundle(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OperandBundle", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TypeValues, &chunk->thunks, NULL)) goto L0001;
        goto L0002;
    L0001:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
    L0002:;
    }
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OperandBundle", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OperandBundle", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OverflowFlags(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OverflowFlags", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlagList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OverflowFlags", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OverflowFlags", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OverflowFlagList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OverflowFlagList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlag, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlagList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_OverflowFlag, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OverflowFlagList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OverflowFlagList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OverflowFlag(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OverflowFlag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'w'
        ) goto L0002;
        ctx->cur += 3;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'w'
        ) goto L0003;
        ctx->cur += 3;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OverflowFlag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OverflowFlag", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ParamAttrs(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ParamAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamAttrList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ParamAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ParamAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ParamAttrList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ParamAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamAttr, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamAttrList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamAttr, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ParamAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ParamAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ParamAttr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ParamAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Dereferenceable, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'v' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l'
        ) goto L0005;
        ctx->cur += 5;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'a'
        ) goto L0006;
        ctx->cur += 8;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'g'
        ) goto L0007;
        ctx->cur += 5;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 's' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't'
        ) goto L0008;
        ctx->cur += 4;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 's'
        ) goto L0009;
        ctx->cur += 7;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 't' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'e'
        ) goto L0010;
        ctx->cur += 9;
        goto L0001;
    L0010:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'l'
        ) goto L0011;
        ctx->cur += 7;
        goto L0001;
    L0011:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e'
        ) goto L0012;
        ctx->cur += 8;
        goto L0001;
    L0012:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'y'
        ) goto L0013;
        ctx->cur += 8;
        goto L0001;
    L0013:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 8) < 8 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 't' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'd'
        ) goto L0014;
        ctx->cur += 8;
        goto L0001;
    L0014:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't'
        ) goto L0015;
        ctx->cur += 7;
        goto L0001;
    L0015:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 4) < 4 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't'
        ) goto L0016;
        ctx->cur += 4;
        goto L0001;
    L0016:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 10) < 10 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'r'
        ) goto L0017;
        ctx->cur += 10;
        goto L0001;
    L0017:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[4] != 't' ||
            (ctx->buffer.buf + ctx->cur)[5] != 's' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'f'
        ) goto L0018;
        ctx->cur += 9;
        goto L0001;
    L0018:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'w' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'y'
        ) goto L0019;
        ctx->cur += 9;
        goto L0001;
    L0019:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't'
        ) goto L0020;
        ctx->cur += 7;
        goto L0001;
    L0020:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ParamAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ParamAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Params(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Params", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != '.' ||
            (ctx->buffer.buf + ctx->cur)[1] != '.' ||
            (ctx->buffer.buf + ctx->cur)[2] != '.'
        ) goto L0002;
        ctx->cur += 3;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamList, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamList, &chunk->thunks, NULL)) goto L0004;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0004;
        ctx->cur++;
        if (
            pcc_refill_buffer(ctx, 3) < 3 ||
            (ctx->buffer.buf + ctx->cur)[0] != '.' ||
            (ctx->buffer.buf + ctx->cur)[1] != '.' ||
            (ctx->buffer.buf + ctx->cur)[2] != '.'
        ) goto L0004;
        ctx->cur += 3;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Params", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Params", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ParamList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ParamList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Param, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamList, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ','
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Param, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ParamList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ParamList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Param(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Param", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0002;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamAttrs, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Type, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ParamAttrs, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_LocalIdent, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Param", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Param", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptPreemptionSpecifier(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptPreemptionSpecifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_PreemptionSpecifier, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptPreemptionSpecifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptPreemptionSpecifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_PreemptionSpecifier(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "PreemptionSpecifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'l'
        ) goto L0002;
        ctx->cur += 9;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 15) < 15 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 's' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != '_' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[10] != 't' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'b' ||
            (ctx->buffer.buf + ctx->cur)[13] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'e'
        ) goto L0003;
        ctx->cur += 15;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "PreemptionSpecifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "PreemptionSpecifier", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ReturnAttrs(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ReturnAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ReturnAttrList, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ReturnAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ReturnAttrs", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ReturnAttrList(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ReturnAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ReturnAttr, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ReturnAttrList, &chunk->thunks, NULL)) goto L0003;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ReturnAttr, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ReturnAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ReturnAttrList", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ReturnAttr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ReturnAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Alignment, &chunk->thunks, NULL)) goto L0002;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Dereferenceable, &chunk->thunks, NULL)) goto L0003;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0004;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 5) < 5 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'g'
        ) goto L0005;
        ctx->cur += 5;
        goto L0001;
    L0005:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 's'
        ) goto L0006;
        ctx->cur += 7;
        goto L0001;
    L0006:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'l'
        ) goto L0007;
        ctx->cur += 7;
        goto L0001;
    L0007:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 's' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'g' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't'
        ) goto L0008;
        ctx->cur += 7;
        goto L0001;
    L0008:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'z' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't'
        ) goto L0009;
        ctx->cur += 7;
        goto L0001;
    L0009:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ReturnAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ReturnAttr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptSection(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptSection", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Section, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptSection", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptSection", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Section(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Section", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 7) < 7 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[3] != 't' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'n'
    ) goto L0000;
    ctx->cur += 7;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Section", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Section", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_StackAlignment(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "StackAlignment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 10) < 10 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'g' ||
        (ctx->buffer.buf + ctx->cur)[4] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[5] != 's' ||
        (ctx->buffer.buf + ctx->cur)[6] != 't' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[9] != 'k'
    ) goto L0000;
    ctx->cur += 10;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_int_lit, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "StackAlignment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "StackAlignment", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptSyncScope(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptSyncScope", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 9) < 9 ||
        (ctx->buffer.buf + ctx->cur)[0] != 's' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'y' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[4] != 's' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'p' ||
        (ctx->buffer.buf + ctx->cur)[8] != 'e'
    ) goto L0000;
    ctx->cur += 9;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != '('
    ) goto L0000;
    ctx->cur++;
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_StringLit, &chunk->thunks, NULL)) goto L0000;
    if (
        pcc_refill_buffer(ctx, 1) < 1 ||
        ctx->buffer.buf[ctx->cur] != ')'
    ) goto L0000;
    ctx->cur++;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptSyncScope", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptSyncScope", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptThreadLocal(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptThreadLocal", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_ThreadLocal, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptThreadLocal", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptThreadLocal", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_ThreadLocal(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "ThreadLocal", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'l'
        ) goto L0002;
        ctx->cur += 12;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 't' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[6] != '_' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'l'
        ) goto L0003;
        ctx->cur += 12;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != '('
        ) goto L0003;
        ctx->cur++;
        if (!pcc_apply_rule(ctx, pcc_evaluate_rule_TLSModel, &chunk->thunks, NULL)) goto L0003;
        if (
            pcc_refill_buffer(ctx, 1) < 1 ||
            ctx->buffer.buf[ctx->cur] != ')'
        ) goto L0003;
        ctx->cur++;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "ThreadLocal", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "ThreadLocal", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_TLSModel(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "TLSModel", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 11) < 11 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'c'
        ) goto L0002;
        ctx->cur += 11;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'y' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'c'
        ) goto L0003;
        ctx->cur += 12;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'x' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'c'
        ) goto L0004;
        ctx->cur += 9;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "TLSModel", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "TLSModel", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptUnnamedAddr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptUnnamedAddr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_UnnamedAddr, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptUnnamedAddr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptUnnamedAddr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_UnnamedAddr(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "UnnamedAddr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 18) < 18 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[5] != '_' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[12] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[13] != '_' ||
            (ctx->buffer.buf + ctx->cur)[14] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[15] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[16] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[17] != 'r'
        ) goto L0002;
        ctx->cur += 18;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 12) < 12 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'n' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'm' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[6] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[7] != '_' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[9] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[10] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[11] != 'r'
        ) goto L0003;
        ctx->cur += 12;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "UnnamedAddr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "UnnamedAddr", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptVisibility(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptVisibility", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (!pcc_apply_rule(ctx, pcc_evaluate_rule_Visibility, &chunk->thunks, NULL)) goto L0000;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptVisibility", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptVisibility", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_Visibility(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "Visibility", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    {
        const size_t p = ctx->cur;
        const size_t n = chunk->thunks.len;
        if (
            pcc_refill_buffer(ctx, 7) < 7 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'f' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'u' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'l' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't'
        ) goto L0002;
        ctx->cur += 7;
        goto L0001;
    L0002:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 6) < 6 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'h' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'i' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[3] != 'd' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'n'
        ) goto L0003;
        ctx->cur += 6;
        goto L0001;
    L0003:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        if (
            pcc_refill_buffer(ctx, 9) < 9 ||
            (ctx->buffer.buf + ctx->cur)[0] != 'p' ||
            (ctx->buffer.buf + ctx->cur)[1] != 'r' ||
            (ctx->buffer.buf + ctx->cur)[2] != 'o' ||
            (ctx->buffer.buf + ctx->cur)[3] != 't' ||
            (ctx->buffer.buf + ctx->cur)[4] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[5] != 'c' ||
            (ctx->buffer.buf + ctx->cur)[6] != 't' ||
            (ctx->buffer.buf + ctx->cur)[7] != 'e' ||
            (ctx->buffer.buf + ctx->cur)[8] != 'd'
        ) goto L0004;
        ctx->cur += 9;
        goto L0001;
    L0004:;
        ctx->cur = p;
        pcc_thunk_array__revert(ctx->auxil, &chunk->thunks, n);
        goto L0000;
    L0001:;
    }
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "Visibility", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "Visibility", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

static pcc_thunk_chunk_t *pcc_evaluate_rule_OptVolatile(llvmir_context_t *ctx) {
    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx->auxil);
    chunk->pos = ctx->cur;
    PCC_DEBUG(PCC_DBG_EVALUATE, "OptVolatile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->buffer.len - chunk->pos));
    ctx->level++;
    pcc_value_table__resize(ctx->auxil, &chunk->values, 0);
    pcc_capture_table__resize(ctx->auxil, &chunk->capts, 0);
    if (
        pcc_refill_buffer(ctx, 8) < 8 ||
        (ctx->buffer.buf + ctx->cur)[0] != 'v' ||
        (ctx->buffer.buf + ctx->cur)[1] != 'o' ||
        (ctx->buffer.buf + ctx->cur)[2] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[3] != 'a' ||
        (ctx->buffer.buf + ctx->cur)[4] != 't' ||
        (ctx->buffer.buf + ctx->cur)[5] != 'i' ||
        (ctx->buffer.buf + ctx->cur)[6] != 'l' ||
        (ctx->buffer.buf + ctx->cur)[7] != 'e'
    ) goto L0000;
    ctx->cur += 8;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_MATCH, "OptVolatile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    return chunk;
L0000:;
    ctx->level--;
    PCC_DEBUG(PCC_DBG_NOMATCH, "OptVolatile", ctx->level, chunk->pos, (ctx->buffer.buf + chunk->pos), (ctx->cur - chunk->pos));
    pcc_thunk_chunk__destroy(ctx->auxil, chunk);
    return NULL;
}

llvmir_context_t *llvmir_create(void *auxil) {
    return pcc_context__create(auxil);
}

int llvmir_parse(llvmir_context_t *ctx, int *ret) {
    pcc_thunk_array_t thunks;
    pcc_thunk_array__init(ctx->auxil, &thunks, PCC_ARRAYSIZE);
    if (pcc_apply_rule(ctx, pcc_evaluate_rule_llvmir, &thunks, ret))
        pcc_do_action(ctx, &thunks, ret);
    else
        PCC_ERROR(ctx->auxil);
    pcc_commit_buffer(ctx);
    pcc_thunk_array__term(ctx->auxil, &thunks);
    return pcc_refill_buffer(ctx, 1) >= 1;
}

void llvmir_destroy(llvmir_context_t *ctx) {
    pcc_context__destroy(ctx);
}


int main() {
    llvmir_context_t *ctx=llvmir_create(NULL);
    while (llvmir_parse(ctx, NULL)){;}
    llvmir_destroy(ctx);
    return 0;
}

